programming python

Hướng dẫn how to convert array to object in python - làm thế nào để chuyển đổi mảng thành đối tượng trong python

Bạn có thể sử dụng một bộ tích lũy AKA 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46.

['a','b','c'].reduce[function[result, item, index, array] {
  result[index] = item; //a, b, c
  return result;
}, {}] //watch out the empty {}, which is passed as "result"

Vượt qua một đối tượng trống 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
47 làm điểm bắt đầu; sau đó "tăng cường" đối tượng đó tăng dần. Vào cuối các lần lặp, 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
48 sẽ là 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
49

Nếu mảng của bạn là một tập hợp các đối tượng cặp giá trị khóa:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];

sẽ sản xuất: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
50

Để hoàn thiện, 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
51 cho phép bạn lặp lại mảng của mình theo thứ tự ngược lại:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]

sẽ sản xuất: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
52

Bộ tích lũy của bạn có thể thuộc bất kỳ loại nào cho mục đích cụ thể của bạn. Ví dụ: để hoán đổi khóa và giá trị của đối tượng của bạn trong một mảng, Pass 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
53:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array

sẽ sản xuất: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
54

Không giống như 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
55, 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46 có thể không được sử dụng dưới dạng ánh xạ 1-1. Bạn có toàn quyền kiểm soát các mục bạn muốn bao gồm hoặc loại trừ. Do đó, 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46 cho phép bạn đạt được những gì 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
58 làm, điều này làm cho 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46 rất linh hoạt:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array

sẽ sản xuất: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
60

THẬN TRỌNG: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
62 là một phần của 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
63; Bạn nên cung cấp một polyfill cho các trình duyệt không hỗ trợ họ [đáng chú ý là IE8].: 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
46 and 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
62 are part of 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
63; you should provide a polyfill for browsers that don't support them [notably IE8].

Xem một triển khai mặc định của Mozilla.

Cách chuyển đổi sang/từ các đối tượng Python#

Các đối tượng Python được xây dựng như Dicts và Danh sách có thể được chuyển đổi thành các mảng khó xử, và tất cả các mảng khó xử có thể được chuyển đổi thành các đối tượng Python. Thông tin loại khó xử, chẳng hạn như sự khác biệt giữa các danh sách có kích thước cố định và độ dài thay đổi, bị mất trong quá trình chuyển đổi thành các đối tượng Python.

import awkward as ak
import numpy as np
import pandas as pd

Từ Python đến vụng về#

Hàm cho Python → Chuyển đổi khó xử là ak.from_iter.

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects


[[1.1, 2.2, 3.3], [], [4.4, 5.5]]

________số 8

Xem các phần dưới đây để biết cách các loại python được ánh xạ tới các loại khó xử.

Lưu ý rằng điều này nên được coi là một hàm chậm, sử dụng nhiều bộ nhớ: không chỉ cần lặp lại dữ liệu Python, mà còn cần khám phá loại dữ liệu dần dần. Trong nội bộ, chức năng này sử dụng AK.ArrayBuilder để tích lũy dữ liệu và khám phá đồng thời các loại. Ví dụ, Don Tiết, chuyển đổi một bộ dữ liệu lớn, số từ Numpy hoặc mũi tên thành các đối tượng Python chỉ để sử dụng ak.from_iter. Có các chức năng chuyên dụng cho điều đó: Xem hướng dẫn của họ [thanh bên trái hoặc nút trên điện thoại di động].

Đây cũng là hoạt động dự phòng của các nhà xây dựng AK.Array và AK.Record. Thông thường, các ví dụ nhỏ được xây dựng bằng cách chuyển các đối tượng Python trực tiếp cho các hàm tạo này.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
0




[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
2

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
3

Từ khó xử đến Python#

Chức năng cho sự khó xử → Chuyển đổi Python là ak.to_list.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
4




[[1.1, 2.2, 3.3], [], [4.4, 5.5]]


[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
7

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
3

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
9

Lưu ý rằng điều này nên được coi là một hàm chậm, sử dụng nhiều bộ nhớ, như ak.from_iter. Ví dụ, Don Tiết, chuyển đổi một bộ dữ liệu lớn, số bằng ak.to_list chỉ để chuyển đổi các danh sách đó thành numpy hoặc mũi tên. Có các chức năng chuyên dụng cho điều đó: Xem hướng dẫn của họ [thanh bên trái hoặc nút trên điện thoại di động].

Các mảng và hồ sơ khó xử có một phương thức 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
64 [lưu ý: không có dấu gạch dưới], đó là một sự tương tự của Tolist Numpy. Đối với các bộ dữ liệu nhỏ [hoặc một lát nhỏ của bộ dữ liệu], đây là một cách thuận tiện để có được một cái nhìn nhanh.

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
0

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
1

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
2

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
3

Constructor kiểu gấu trúc#

Như chúng ta đã thấy, Trình xây dựng AK.Array diễn giải một đối số có thể lặp lại là dữ liệu mà nó có nghĩa là để đại diện, như trong:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
4

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]

Nhưng đôi khi, bạn có một số vòng lặp mà bạn muốn sử dụng làm cột của bảng. Trình xây dựng Pandas DataFrame diễn giải một phương pháp của Iterables là các cột:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
7

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
8

xy012
[1.1, 2.2, 3.3]một
[]hai
[4.4, 5.5]số ba

Và trình xây dựng AK.Array cũng vậy:

[{ a: 1},{ b: 2},{ c: 3}].reduceRight[/* same implementation as above */]
9

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
0

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
1

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
2

Lưu ý rằng đây là sự chuyển đổi của cách giải thích dữ liệu nếu nó nằm trong danh sách, thay vì chỉ đạo. Các giá trị 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
65 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
66 được hiểu là được xen kẽ trong mỗi bản ghi. Không có tiềm năng xung đột giữa các nhà xây dựng kiểu AK.From_ITER và kiểu gandas vì ak.from_iter áp dụng cho một dict sẽ luôn trả lại một ak.record, thay vì ak.array.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
3

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
4

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
5

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
6

Hàm ak.from_iter được áp dụng cho một dict cũng tương đương với hàm tạo AK.Record.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
7

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
4

Chuyển đổi số và booleans#

Python 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
67, 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
68 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
69 [được gọi là các loại nguyên thủy]] được chuyển đổi thành các loại 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
70, 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
71 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
69 trong các mảng khó xử.

Tất cả các loại khó xử dấu phẩy động được chuyển đổi thành Python từ 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
67, tất cả các loại khó xử tích phân được chuyển đổi thành Python tựa 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
68, và loại Boolean vụng về được chuyển đổi thành Python tựa 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
69.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  var key = Object.keys[item][0]; //first property: a, b, c
  var value = item[key];
  var obj = {};
  obj[value] = key;
  result.push[obj];
  return result;
}, []]; //an empty array
9

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
0

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
1

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
2

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
3

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
4

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
5

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
6

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
7

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item, index] {
  if[index !== 0] { //skip the first item
    result.push[item];
  }
  return result;
}, []]; //an empty array
8

Chuyển đổi danh sách#

Danh sách Python, cũng như các vòng lặp khác ngoài Dict, Tuple, Str và Byte, được chuyển đổi thành danh sách có độ dài thay đổi vụng về. Không thể xây dựng các danh sách kích thước cố định với ak.from_iter. [Một cách để làm điều đó là bằng cách chuyển đổi một mảng numpy với ak.from_numpy.]

Danh sách chiều dài và kích thước cố định của Wetwward, được chuyển đổi thành danh sách Python với AK.TO_List.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
0




import awkward as ak
import numpy as np
import pandas as pd
1

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]


import awkward as ak
import numpy as np
import pandas as pd
3

import awkward as ak
import numpy as np
import pandas as pd
4

import awkward as ak
import numpy as np
import pandas as pd
5

Ghi chú

Chủ đề nâng cao: Phần còn lại của phần này có thể bị bỏ qua nếu bạn không quan tâm đến sự khác biệt giữa danh sách có kích thước cố định và độ dài thay đổi.

Lưu ý rằng một mảng numpy là một điều có thể đi được, vì vậy ak.from_iter lặp lại trên nó, xây dựng các danh sách khó xử có độ dài thay đổi. Ngược lại, ak.from_numpy chuyển dữ liệu [không có sự lặp lại] vào các danh sách khó xử có kích thước cố định.

import awkward as ak
import numpy as np
import pandas as pd
6

import awkward as ak
import numpy as np
import pandas as pd
7

import awkward as ak
import numpy as np
import pandas as pd
8

import awkward as ak
import numpy as np
import pandas as pd
9

Lưu ý rằng các loại khác nhau: 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
76 so với 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
77. Trình xây dựng AK.Array sử dụng ak.from_numpy nếu được cho một mảng numpy [với 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
78] và ak.from_iter nếu được cho một số không thể nhận ra.

Điều này có thể đặc biệt tinh tế khi các mảng numpy được lồng trong vòng lặp.

import awkward as ak
import numpy as np
import pandas as pd
6

import awkward as ak
import numpy as np
import pandas as pd
7

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
2

import awkward as ak
import numpy as np
import pandas as pd
9

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
4

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
5

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
6

import awkward as ak
import numpy as np
import pandas as pd
8

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
8

py_objects = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
py_objects
9

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
0

import awkward as ak
import numpy as np
import pandas as pd
8

Logic đằng sau chính sách này là chỉ có các mảng numpy với 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
78 được đảm bảo có nội dung có kích thước cố định. Các trường hợp khác phải có danh sách loại 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
80.

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
2

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
3




[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
5

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
6

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
7

Chuyển đổi chuỗi và bytestrings#

Các chuỗi Python [loại 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
81] được chuyển đổi thành và từ các chuỗi được mã hóa và python của UTF-8 vụng về [loại 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
82] được chuyển đổi thành và từ những điều không được mã hóa.

[[1.1, 2.2, 3.3], [], [4.4, 5.5]]
9

ak_array = ak.from_iter[py_objects]
ak_array
0

ak_array = ak.from_iter[py_objects]
ak_array
1

ak_array = ak.from_iter[py_objects]
ak_array
2

ak_array = ak.from_iter[py_objects]
ak_array
3

ak_array = ak.from_iter[py_objects]
ak_array
4

ak_array = ak.from_iter[py_objects]
ak_array
5

ak_array = ak.from_iter[py_objects]
ak_array
6

Ghi chú

Chủ đề nâng cao: Phần còn lại của phần này có thể bị bỏ qua nếu bạn không quan tâm đến các đại diện nội bộ.

Chuỗi vụng về và bytestrings không phải là loại riêng biệt, mà là các chuyên ngành của các danh sách có độ dài thay đổi. Trong khi một danh sách có thể được thể hiện nội bộ bởi một ListArray hoặc ListoffsetArray,

ak_array = ak.from_iter[py_objects]
ak_array
7

ak_array = ak.from_iter[py_objects]
ak_array
8

Chuỗi và bytestrings chỉ là ListArrays và ListoffsetArrays của các số nguyên một byte với các tham số đặc biệt:

ak_array = ak.from_iter[py_objects]
ak_array
9
0

Các tham số này chỉ ra rằng các mảng chuỗi nên có các hành vi đặc biệt, chẳng hạn như bình đẳng mỗi chuỗi, thay vì bình đẳng cho mỗi ký tự.
1
2
3
4

.

Các hành vi đặc biệt cho các chuỗi được thực hiện bằng cách sử dụng cùng một cơ chế AK.Behavior mà bạn có thể sử dụng để đưa ra các hành vi đặc biệt cho các mảng và hồ sơ.
5
6
7
8
9

Thực tế là các chuỗi thực sự chỉ là danh sách có độ dài thay đổi là đáng để ghi nhớ, vì chúng có thể hành xử theo những cách giống như danh sách bất ngờ. Nếu bạn nhận thấy bất kỳ hành vi nào nên được phủ nhận cho các chuỗi, hãy đề xuất nó như một yêu cầu tính năng.

Chuyển đổi các dicts và Tuples#

Python dicts với các khóa có giá trị chuỗi được chuyển đổi đến và từ loại bản ghi vụng về với các trường được đặt tên. Dữ liệu được liên kết với các trường khác nhau có thể có các loại khác nhau, nhưng bạn thường muốn dữ liệu được liên kết với tất cả các trường hợp của cùng một trường để có cùng loại. Python dicts với các phím không có giá trị không có chuỗi không có tương đương trong mảng khó xử [các bản ghi rất khác với ánh xạ].

Các bộ dữ liệu Python được chuyển đổi đến và từ loại kỷ lục vụng về với các trường không tên. Lưu ý rằng các chế độ xem vụng về danh sách và bộ dữ liệu Python theo những cách rất khác nhau: Danh sách dự kiến ​​sẽ có độ dài thay đổi với tất cả các yếu tố có cùng loại, trong khi các bộ dữ liệu được dự kiến ​​sẽ có kích thước cố định với các yếu tố có khả năng khác nhau, giống như một bản ghi.

Trong ví dụ sau, trường 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
65 có loại 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
71 và trường 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
66 có loại 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
76.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
00

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
01

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
02

Dưới đây là ví dụ tương ứng với Tuples:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
03

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
04

Cả hai loại khó xử này, 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
91 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
92, có hai trường, nhưng cái đầu tiên có tên cho các trường đó.

Cả hai có thể được trích xuất bằng cách sử dụng các chuỗi giữa các dấu ngoặc vuông, mặc dù các chuỗi phải là 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
93 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
94 cho bộ tuple.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
05

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
06

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
05

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
06

Lưu ý sự khác biệt về ý nghĩa giữa 

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
94 và 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
96 trong ví dụ trên. Để an toàn, bạn có thể muốn sử dụng các phương thức 
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
97 với Tuples:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
05

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
06

Hoặc có thể là ak.unzip:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
11

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
05

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
13

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
05

Bằng cách đó, bạn có thể đặt tên cho các biến bất cứ thứ gì bạn thích.

Nếu các trường bị thiếu trong một số bản ghi, các giá trị bị thiếu sẽ được điền vào không có [loại tùy chọn: thêm về bên dưới].

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
15

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
16

Nếu một số bộ dữ liệu có độ dài khác nhau, kết quả là mảng khó xử được coi là không đồng nhất [loại liên minh: nhiều hơn về điều đó bên dưới].

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
17

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
18

Một bản ghi khó xử là một vô hướng được rút ra từ một mảng kỷ lục, do đó, một ak.record có thể được xây dựng từ một dict duy nhất với các khóa có giá trị chuỗi.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
19

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
20

Điều tương tự không đúng với bộ dữ liệu. Trình xây dựng AK.Record mong đợi các trường được đặt tên.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
21

Thiếu giá trị: Python không có#

Python không có ai có thể xuất hiện ở bất cứ đâu trong cấu trúc được phân tích bởi ak.from_iter. Nó làm cho tất cả dữ liệu ở cấp độ làm tổ có loại tùy chọn và được biểu diễn trong AK.TO_LIST dưới dạng không.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
22

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
23

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
24

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
25

Ghi chú

Chủ đề nâng cao: Phần còn lại của phần này có thể bị bỏ qua nếu bạn không quan tâm đến các đại diện nội bộ.

Chuỗi vụng về và bytestrings không phải là loại riêng biệt, mà là các chuyên ngành của các danh sách có độ dài thay đổi. Trong khi một danh sách có thể được thể hiện nội bộ bởi một ListArray hoặc ListoffsetArray,

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
26

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
27

Chuỗi và bytestrings chỉ là ListArrays và ListoffsetArrays của các số nguyên một byte với các tham số đặc biệt:

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
28

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
29

Nhưng các bộ dữ liệu điển hình của các bản ghi với các bộ trường khác nhau đại diện cho các trường bị thiếu, thay vì các loại đối tượng hoàn toàn khác nhau. . nhưng không phải photon.]

Việc sử dụng bộ nhớ của các mảng liên minh với số lượng các loại khác nhau, lên đến \ [2^n \] cho các bản ghi với các trường \ [n \] có khả năng bị thiếu. Các loại tùy chọn của các bản ghi phân tách hoàn toàn với các trường \ [N_1 \] và \ [N_2 \] Sử dụng dấu chân bộ nhớ có tỷ lệ là \ [N_1 + N_2 \]. Giả sử rằng các bản ghi Disjoint là một loại bản ghi duy nhất với các trường bị thiếu là một sai lầm có thể phục hồi, nhưng giả sử rằng một loại bản ghi duy nhất với các trường bị thiếu là khác biệt đối với mỗi kết hợp các trường bị thiếu có khả năng là thảm họa.\[2^n\] for records with \[n\] potentially missing fields. Option types of completely disjoint records with \[n_1\] and \[n_2\] fields use a memory footprint that scales as \[n_1 + n_2\]. Assuming that disjoint records are a single record type with missing fields is a recoverable mistake, but assuming that a single record type with missing fields are distinct for every combination of missing fields is potentially disastrous.

Mặt khác, các bộ dữ liệu có độ dài khác nhau được coi là các loại khác nhau vì nhầm khe \ [i \] cho khe \ [i + 1 \] dù sao cũng sẽ tạo ra các công đoàn.\[i\] for slot \[i + 1\] would create unions anyway.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
30

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
31

Các loại liên minh: Dữ liệu không đồng nhất#

Nếu dữ liệu trong một python có thể có các loại khác nhau ở cùng mức độ làm tổ [không đồng nhất], các mảng khó xử được tạo ra bởi ak.from_iter có các loại liên minh.

Hầu hết các hoạt động khó xử đều được xác định trên các mảng được đánh máy liên minh, nhưng chúng thường không hiệu quả như các hoạt động giống nhau trên các mảng được gõ đơn giản.

Ví dụ sau đây trộn các số [

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
70] với danh sách [
[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
76].

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
32

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
33

Hàm ak.to_list chuyển đổi nó trở lại thành một danh sách python không đồng nhất.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
34

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
35

Bất kỳ loại nào có thể được trộn lẫn: số và danh sách, danh sách và hồ sơ, dữ liệu bị thiếu, v.v.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
36

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
37

Một ngoại lệ là dữ liệu số được hợp nhất mà không tạo ra loại liên kết: Số nguyên được mở rộng thành số điểm nổi.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
38

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
39

Nhưng Booleans không được hợp nhất với số nguyên.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
40

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
41

Như đã mô tả ở trên, các bản ghi với các tập hợp các trường khác nhau được coi là một loại bản ghi duy nhất có các giá trị bị thiếu.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
42

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
43

Nhưng các bộ dữ liệu có độ dài khác nhau được coi là các loại riêng biệt.

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
44

[{ a: 1},{ b: 2},{ c: 3}].reduce[function[result, item] {
  var key = Object.keys[item][0]; //first property: a, b, c
  result[key] = item[key];
  return result;
}, {}];
45

Điều khiển nhiều chuyển đổi hơn#

Các chuyển đổi được mô tả ở trên được áp dụng bởi ak.from_iter khi nó ánh xạ dữ liệu thành một ak.arraybuilder. Để kiểm soát nhiều hơn đối với quy trình chuyển đổi [ví dụ: để tạo các công đoàn của hồ sơ], hãy sử dụng trực tiếp AK.ArrayBuilder.

Làm thế nào để bạn biến một mảng thành một đối tượng?

Để chuyển đổi một mảng thành một đối tượng, hãy sử dụng phương thức giảm [] để lặp qua mảng, chuyển nó một đối tượng làm giá trị ban đầu. Trên mỗi lần lặp, gán một cặp giá trị khóa mới cho đối tượng tích lũy và trả về kết quả. Đã sao chép!use the reduce[] method to iterate over the array, passing it an object as the initial value. On each iteration, assign a new key-value pair to the accumulated object and return the result. Copied!

Làm thế nào để bạn chuyển đổi thành một đối tượng trong Python?

Sử dụng hàm json.loads [].JSON.Hàm tải [] chấp nhận làm đầu vào một chuỗi hợp lệ và chuyển đổi nó thành từ điển Python.Quá trình này được gọi là Deserialization - hành động chuyển đổi một chuỗi thành một đối tượng. loads[] function. The json. loads[] function accepts as input a valid string and converts it to a Python dictionary. This process is called deserialization – the act of converting a string to an object.

Làm cách nào để chuyển đổi một mảng thành một hình ảnh trong Python?

Cho một mảng numpy, chúng ta cần chuyển đổi nó thành một hình ảnh trong Python ...
Nhập thư viện Numpy và tạo mảng 2D Numpy bằng phương thức randint [] ..
Chuyển mảng này cho phương thức FromArray [].Điều này sẽ trả về một đối tượng hình ảnh ..
Lưu hình ảnh vào hệ thống tập tin bằng phương thức Save [] ..

Bạn có thể tạo một loạt các đối tượng trong Python không?

Mô -đun mảng trong Python xác định một đối tượng được biểu diễn trong một mảng.Đối tượng này chứa các loại dữ liệu cơ bản như số nguyên, điểm nổi và ký tự.Sử dụng mô -đun mảng, một mảng có thể được khởi tạo bằng cú pháp sau.. This object contains basic data types such as integers, floating points, and characters. Using the array module, an array can be initialized using the following syntax.

Bài Viết Liên Quan

Hướng dẫn python for trading - con trăn để giao dịch
Mã giảm giá tiki 2023
Hướng dẫn how can i get url extension in php? - làm cách nào để lấy phần mở rộng url trong php?
Hướng dẫn implicit coercion in javascript - ép buộc ngầm trong javascript
Hướng dẫn functions in python example - các hàm trong ví dụ python
Tim noi dung file trong linux
Hướng dẫn can panda read excel files? - gấu trúc có thể đọc các tập tin excel?
Hướng dẫn python flow control exercises - bài tập kiểm soát dòng chảy của trăn
Hướng dẫn how to push function into array in javascript - cách đẩy hàm vào mảng trong javascript
Hướng dẫn 20 python programs with output for class 12 pdf - 20 chương trình python với đầu ra cho pdf lớp 12
Hướng dẫn dùng translata python - 英语 con trăn đã dịch
Hướng dẫn how do you check if php is working on windows? - làm thế nào để bạn kiểm tra xem php có hoạt động trên windows hay không?
Linux chứa danh sách những user bị cấm truy cập
Bảng giá vé tàu tết năm 2023
Hướng dẫn sublime text 4 php - văn bản siêu phàm 4 php
Hướng dẫn how do you capitalize the first letter of each string in a list python? - làm thế nào để bạn viết hoa chữ cái đầu tiên của mỗi chuỗi trong một python danh sách?
Hướng dẫn php-mvc example with database github - ví dụ php-mvc với github cơ sở dữ liệu
Hướng dẫn print return value of function javascript - in giá trị trả về của hàm javascript
Hướng dẫn php remove http https from string - php xóa http https khỏi chuỗi
Hướng dẫn why multiple inheritance is not supported in php - tại sao đa kế thừa không được hỗ trợ trong php

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Bài mới nhất

Lỗi không cài dat dirve may in sp7000 năm 2024
Lý luận mác lênin có phải đã lỗi thời năm 2024
Lỗi font chữ trong tiêu đề thư trong outlook 2007 năm 2024
Bệnh viêm mô tế bào là gì năm 2024
Lỗi trùng chưng minh thư của người phụ thuộc năm 2024
Viết một đoạn văn tả cây bóng mát năm 2024
Giải bài 12 sbt toán 9 tập 1 trang 62 năm 2024
Bất tử khác với bất diệt ở chỗ nào năm 2024
Top 10 headhunt tuyen dung bat dong san hieu qua năm 2024
Bài tập đệ quy quay lui trong c năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Mẹo Hay Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập So sánh Tiếng anh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học