リスト — プログラミング言語 Ring 1.14 取扱説明書

Skip to content

# リスト

リストの用法です。

## リストの作成

角括弧の内側にリストを定義することで、新しいリストを作成できます。

用例:

    aList = [1,2,3,4,5]

また : 演算子や、

用例:

    aList = 1:5
    aList2 = "a":"z"

用例:

    aList = 5:1
    aList2 = "z":"a"

list() 関数でも新しいリストを作成できます。

文法:

    list = list(size)

二次元リストを作成するには、

    list = list(nRows,nCols)

用例 (1)

    aList = list(10)        # aList で 10 項目を割り当てます。

用例 (2)

    aList = list(5,4)       # 5 行 4 列からなる二次元リストを作成します。

注釈

リストのインデックスは 1 が始点となります。

## 項目の追加

Add() 関数はリストへ新しい項目を追加します。

文法:

    Add(List,Item)

用例:

    aList = ["one","two"]
    add(aList,"three")
    see aList

+ 演算子も使えます。

文法:

    リスト + 項目

用例:

    aList = 1:10    # 1 ～ 10 までの数値を有するリストを作成します。
    aList + 11      # リストへ数値 11 を追加
    see aList       # リストを表示

## リストのサイズ取得

len() 関数はリストのサイズを取得します。

文法:

    Len(List)

用例:

    aList = 1:20  see len(aList)  # 20 を表示

## リスト項目の削除

del() 関数はリストから項目を削除します。

文法:

    del(list,index)

用例:

    aList = ["one","two","other","three"]
    Del(aList,3)    # 3 番目の項目を削除
    see aList       # one two three を表示

## リスト項目の取得

リストから項目を取得するには、

文法:

    List[Index]

用例:

    aList = ["Cairo","Riyadh"]
    see "Egypt : " + aList[1] + nl +
        "KSA   : " + aList[2] + nl

## リスト項目への代入

リストの項目へ値を代入するには、

文法:

    List[Index] = Expression

用例:

    aList = list(3) # 三項目を有するリストを作成します。
    aList[1] = "one" aList[2] = "two" aList[3] = "three"
    see aList

## 検索

Find() 関数はリスト内の項目を検索します。

文法:

    Find(List,ItemValue)                    ---> 項目のインデックス
    Find(List,ItemValue,nColumn)            ---> nColumn を検索して項目のインデックスを返します。
    Find(List,ItemValue,nColumn,cAttribute) ---> 項目のインデックス

用例:

    aList = ["one","two","three","four","five"]
    see find(aList,"three")         # 3 を表示

用例:

    mylist = [["one",1],
              ["two",2],
              ["three",3]]

    see find(mylist,"two",1) + nl           # 2 を表示
    see find(mylist,2,2) + nl               # 2 を表示

また binarysearch() 関数は整列後のリストを検索します。

文法:

    BinarySearch(List,ItemValue)         ---> 項目のインデックス
    BinarySearch(List,ItemValue,nColumn) ---> nColumn を検索して項目のインデックスを返します。

用例:

    aList = ["one","two","three","four","five"]
    aList = sort(aList)
    see binarysearch(aList,"three")

実行結果:

    five
    four
    one
    three
    two
    4

## 整列

Sort() 関数はリストを整列します。

文法:

    Sort(List)                    ---> 整列後のリスト
    Sort(List,nColumn)            ---> nColumn に基づいて整理されたリスト
    Sort(List,nColumn,cAttribute) ---> 属性に基づいて整列されたリスト

用例:

    aList = [10,12,3,5,31,15]
    aList = sort(aList) see aList # 3 5 10 12 15 31 を表示

文字列の整列もできます。

用例:

    mylist = ["mahmoud","samir","ahmed","ibrahim","mohammed"]
    see mylist                # 整列前のリストを表示
    mylist = sort(mylist)     # リストの整列
    see "list after sort"+nl
    see mylist                # ahmed ibrahim mahmoud mohammed samir を表示

特定の列に基づいてリストを整列できます。

用例:

    aList = [ ["mahmoud",15000] ,
              ["ahmed", 14000 ] ,
              ["samir", 16000 ] ,
              ["mohammed", 12000 ] ,
              ["ibrahim",11000 ] ]

    aList2 = sort(aList,1)
    see aList2

実行結果:

    ahmed
    14000
    ibrahim
    11000
    mahmoud
    15000
    mohammed
    12000
    samir
    16000

## 反転

Reverse() 関数はリストを反転します。

文法:

    Reverse(List) ---> 反転されたリスト

用例:

    aList = [10,20,30,40,50]
    aList = reverse(aList)
    see aList       # 50 40 30 20 10 を表示

## リスト項目の挿入

Insert() 関数はリストへ項目を挿入します。

文法:

    Insert(List,Index,Item)

インデックスの後に項目を挿入します。

用例:

    aList = ["A","B","D","E"]
    insert(aList,2,"C")    # インデックス 2 の後に位置 3 へ "C" を挿入します。
    see aList              # A B C D E を表示

また、 insert(aList, 0 ,Value) で リストの先頭位置 (最初)に項目を挿入します

    aList = 1:5
    insert(aList,0,0)  // リスト、先頭位置 (0)、挿入する項目のデータ
    See aList # 0 ～ 5 までの数値を表示します。

## 多重リスト

リストは他のリストを有しています。

用例:

    aList = [ 1 , [10,20,30] , 5 , [100,1000,5000] ]
    aList2 = [
    "one","two",
    [3,4],
    [20,30], ["three",
              "four",
              "five",[100,200,300]
             ]
    ]

    see aList[2]            # 10 20 30 を表示
    see aList[4][3] + nl    # 5000 を表示
    see aList2[5][2] + nl   # four を表示
    see aList2[5][4][3]     # 300 を表示

## リストのコピー

代入演算子はリスト (多重リストも含む) をコピーします。

用例:

    aList = [
    "one","two",
    [3,4],
    [20,30], ["three",
              "four",
              "five",[100,200,300]
             ]
    ]

    aList2 = aList          # aList から aList2 へコピー
    aList2[5] = "other"     # 項目番号 five を変更
    see aList2[5] + nl      # other を表示
    see aList[5]            # three four five 100 200 300 を表示

## 第一級リスト

リストは 第一級オブジェクト であるため、リストへ変数を格納したり、関数へリストを渡したり、さらに関数からリストを返せます。

用例:

    aList = duplicate( [1,2,3,4,5] )
    see aList[10] + nl                # 5 を表示

    see mylist()                      # 10 20 30 40 50 を表示

    func duplicate list
            nMax = len(list)
            for x = 1 to nMax
                    list + list[x]
            next
            return list

    func mylist return [10,20,30,40,50]

## リストを定義時に使用するには

初回にリストを定義するときに、リストとリスト項目を使用します。

用例:

    aList = [ [1,2,3,4,5] , aList[1] , aList[1] ]
    see aList       # 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 を表示

用例:

    x = [ 1, 2, x ]
    ? x             # 1 2 1 2 を表示
    ? len(x)        # 3 を表示
    ? x[1]          # 1 を表示
    ? x[2]          # 2 を表示
    ? x[3]          # 1 2 を表示

実行結果:

    1
    2
    1
    2

    3
    1
    2
    1
    2

## リストを関数へ渡すには

リストは参照渡しにより関数へ渡されるため、呼び出された関数側でリストの処理や変更ができます。

用例:

    func main
            aList = [1,2,3,4,5]     # Main 関数内でローカルなリストを作成します。
            myfunc(aList)           # リストを参照渡しにすることで、関数を呼び出します。
            see aList               # 1 2 3 4 5 6 7 8 9 10 を表示します。

    func myfunc list
            list + [6,7,8,9,10]

## 文字列インデックスによるリストへのアクセス

項目のインデックスを数値で決定することで、項目の値の設定または項目を取得できますが、 二つの項目を有するリストであり、かつ最初の項目が文字列から構成されている項目ならば、 文字列インデックスで項目へアクセスできます。

用例:

    aList = [ ["one",1] , ["two",2] , ["three",3] ]
    see aList["one"] + nl +
        aList["two"] + nl +
        aList["three"]      # 1 2 3 の表示

この種類のリストは演算子 : および = で定義したほうがより優れたシンタックスになります。

用例:

    aList = [ :one = 1 , :two = 2 , :three = 3 ]
    see aList["one"] + nl +
        aList["two"] + nl +
        aList["three"] + nl # 1 2 3 の表示
    see aList[1]            # one 1 表示

ちなみに

識別子 (単語) の先頭に : (コロン) を付けるとリテラルとして扱われます。

注釈

= で二つの項目を有するリストを定義すると最初の項目は左辺となり、 次の項目は右辺となるリストを作成します。

文字列インデックスでリストへ新しい項目を追加できます。

用例:

    aList = []
    aList["Egypt"] = "Cairo"
    aList["KSA"] = "Riyadh"
    see aList["Egypt"] + nl +       # Cairo を表示
    aList["KSA"] + nl               # Riyadh を表示

## リストによる仮引数または実引数の渡しかた

この種類のリストでは、仮引数の順序は重要ではないため、 関数へ渡すための仮引数としては非常に優れています (順序の変更ができます)。

仮引数は、オプション扱いの場合があります。

用例:

    myconnect (  [ :server = "myserver.com" , :port = 80 ,
                   :username = "mahmoud" , :password = "password" ] )

    func myconnect mypara

            # 接続の詳細を表示
            see "User Name : " + mypara[:username] + nl +
                "Password  : " + mypara[:password] + nl +
                "Server    : " + mypara[:server] + nl +
                "Port      : " + mypara[:port]

## リスト配列による仮引数または実引数の渡しかた

配列形式により、関数へ仮引数また実引数を渡します。

用例:

    myList = [5,7,3,9]    ### 配列は実引数または仮引数のリストです。
    result = sum(myList)
    See "Sum result: "+ result +n

    func sum(aList)
      acc = 0
      sizeList = len(aList)

      for i = 1 to sizeList
         See aList[i] +nl
         acc = acc + aList[i]
      next
    return acc

## リストまたはハッシュテーブルを引数として返すには

関数から配列またはハッシュ形式で引数を返します。

用例:

    sudoku = [  [2,9,0],
                [0,0,1],
                [0,0,0] ]

    aOutput = myFunctionArray(sudoku)
            See "Return Array: T/F: "+ aOutput[1] +" Row: "+ aOutput[2] +" Col: "+ aOutput[3] +nl

    aOutput = myFunctionHash(sudoku)
            See "Return Hash.: T/F: "+ aOutput[:lValue] +" Row: "+ aOutput[:nRow] +" Col: "+ aOutput[:nCol] +nl

    ###--------------------------------
    ### isSolvedSoduku - 配列を返します

    Func myFunctionArray(sudoku)
        for Row = 1 to 9
            for Col = 1 to 9
                if sudoku[Row][Col] = 0

                    //-----------------------------
                    // 三要素から成る配列を返します
                    return [False, Row, Col]
                ok
            next
        next
    return [True, Row, Col]

    ###------------------------------------
    ### isSolvedSoduku - ハッシュを返します

    Func myFunctionHash(sudoku)
        for Row = 1 to 3
            for Col = 1 to 3
                if sudoku[Row][Col] = 0

                    //-----------------------------------------
                    // 三要素から成るハッシュテーブルを返します
                    return  [   :lValue = False,
                                :nRow   = Row,
                                :nCol   = Col
                            ]
                ok
            next
        next

    return  [ :lValue = False, :nRow = Row, :nCol = Col ]

    ###-----------------------------

## リストと再帰による多次元配列の作成方法

指定の大きさによる多次元配列でも関数の再帰で作成できます。

用例:

    ###---------------------------------------------------------------------------------
    ### 配列の作成 -- 指定の大きさの次元:  三次元、四次元、五次元など

    dimList = [4,3,4]
    bList   = createDimList(dimList)

    ###---------------------------------------------------------------------------------
    ### 1 のカウンタを使用して配列へ代入 ,  4x4x4 = 256 , 2x3x4x5x6 = 720

    Counter = 1

    for Col=1 to dimList[1]
      for Row=1 to dimList[2]
        for Dep=1 to dimList[3]
                blist[Col][Row][Dep] = Counter
                Counter++
        next
      next
    next

    ###---------------------------------------------------------------------------------
    ### ブロック形式で配列の要素を表示します。

    for Col=1 to dimList[1]
      for Row=1 to dimList[2]
        for Dep=1 to dimList[3]
                See bList[Col][Row][Dep] See " "
        next
        See nl
      next
        See nl
    next

    ###=================================================================================
    ### 関数

    ###---------------------------------------------------------------------------------
    ### 次元をもつ配列を再帰的に作成します。
    ### 配列の次元を渡すことで呼び出します: dimList = [2,3,4,5]
    ### 最初のエントリーで全ての反復呼び出しの降下を行い newParms を作成します。
    ###
    ### 用例:
    ###    dimList = [4,2,3,2]                <<< 配列形式による次元の大きさと数値です。
    ###    bList   = createDimList(dimList)   <<< 入力からの配列を使用して呼び出します。

    func createDimList(dimArray)

         sizeList = len(dimArray)

         newParms = []
         for i = 2 to sizeList
            Add(newParms, dimArray[i])
         next

         alist = list(dimArray[1])

         if sizeList = 1
            return aList
         ok

         for t in alist
             t = createDimList(newParms)
         next

    return alist

## 項目の交換

Swap() 関数はリスト項目を交換します。

用例:

    aList = [:one,:two,:four,:three]
    see aList
    see copy("*",50) + nl
    swap(aList,3,4)
    see aList

実行結果:

    one
    two
    four
    three
    **************************************************
    one
    two
    three
    four