C#をPythonと比較して学ぶ(第一回：データ)

2024/02/01 C# Python 比較シリーズ

はじめに


プログラミングの世界には様々な言語が存在し、その中でもC#は主にUnityやUnreal Engineなどのゲームエンジンのプログラミング言語として幅広く使われています。一方で、私がよく使っているプログラミング言語であるPythonも、その柔軟性や豊富なライブラリによって広く愛用されています。

このブログでは、私がC#について学んだ内容をPythonのコードと比較しながら紹介していきます。初めてC#に触れる方やPythonに慣れ親しんでいる方にとって、両言語の記述方法や基本事項を比較することで、新たな発見や理解が得られることでしょう。

なお、私がC#について学んだことを元にしていますが、不足している部分や誤っている部分があるかもしれません。その際は、遠慮なくご指摘いただければ幸いです。


目次
  1. はじめに
  2. C#とは
  3. Pythonとは
  4. そもそもプログラムとは
    1. データの取り扱い(第一回)
    2. 処理(第二回)
    3. 部品化と再利用(第三回)
  5. データ型
  6. 変数の宣言と代入
  7. 演算子の比較
  8. 文字列の表示
  9. 配列の操作
  10. 定数の取り扱い
  11. 型推定と型変換
  12. コレクションの比較
  13. まとめ

C#とは

C→C++→C++++(C#)

C#（シーシャープ）は、マイクロソフトが開発したプログラミング言語で、コンピュータープログラムを書くための特別な言葉のようなものです。その名前は、C++という言語をより新しく改良したもので、C++に更に++が付いていることから「Cシャープ」と呼ばれています。

C#は、ゲーム作りやウェブサイト作成、アプリ開発など、さまざまなプログラム作業に使われています。この言語は、JavaやC++といった他のプログラミング言語に似たような形で書かれますが、C++よりも簡単に使えて、プログラムの書き方も少ないことが特徴です。

大事なのは、C#はWindowsというオペレーティングシステムの一部で動くことを前提に作られましたが、今はさまざまな種類のコンピューターで動くようになりました。

プログラムの中で使う言葉や書き方が少し特殊かもしれませんが、このブログではその違いを分かりやすく解説していくつもりです。


Pythonとは


Python（パイソン）は、1991年に生まれたとても使いやすいプログラミング言語です。初心者から上級者まで、広く愛されています。

Pythonの特徴は、コードを書くときに「ホワイトスペース」を大切にすること。これによって、誰でも分かりやすいコードを書くことができます。

型のことを気にせずに、ゴミ箱のようなものがあって、メモリ管理も自動でしてくれるので、ストレスなくプログラミングできます。

さまざまなプログラミングスタイルを選べるのも魅力。そして、豊富なライブラリが用意されているので、手軽に便利なツールを使えます。

WindowsやMac、Linuxなど、様々なコンピューターで使え、無料で手に入るツールがあるのもうれしいポイント。Pythonは簡単で効率的なコードを書くことを奨励しており、文書化も重視されています。


そもそもプログラムとは


プログラムは基本的に、特定の入力データを受け取り、それに対して特定の処理を行い、最終的に出力データを生成します。例えば、ゲーム開発においては、プレイヤーのキー入力が入力データとなり、それに対してキャラクターの動きやゲーム内イベントが処理として行われ、最終的に画面上でのゲームプレイが出力データとなります。

このプログラミングにおいて注力すべきポイントは、まずデータの扱いです。ゲーム内の様々な要素やプレイヤーのアクションに関するデータを正確に理解し、適切に取り扱うことがプログラムの成功につながります。たとえば、プレイヤーのキー入力が確実に検知され、それに対応するゲーム内のアクションが適切に反映されることが求められます。

次に処理の方法が重要です。与えられたプレイヤーのアクションに対してどのようなゲーム内の反応を示すかが、プログラムの中核となります。処理はゲーム内のルールやイベントによって異なり、適切なアルゴリズムやロジックの選択が求められます。例えば、キャラクターの動きや衝突の計算、ゲーム内イベントの進行などが重要な処理となります。

最後に部品化と再利用が大切です。ゲーム開発は多くの場合、複雑で大規模なプロジェクトになります。その際、ゲーム内の要素や機能を小さな部品に分割し、それらを組み合わせてプログラムを構築することが効果的です。これにより、修正や拡張が容易になり、同じ要素や機能が複数回必要な場合も、再利用可能なコードを活用することで効率的な開発が可能となります。

プログラミングはこれらの要素を調和させ、ゲーム開発において最適な解決策を見つけるプロセスとなります。


  • データの取り扱い(第一回)

    プログラミングにおいて、データは入力や出力、変数への格納など、コードを書く上で基本的かつ重要な要素です。データは様々な種類があり、それぞれの性質をデータ型と呼びます。これらのデータ型を組み合わせることで、より複雑な情報を扱うことができます。

    例えば、C#とPythonでは各々異なるデータ型の取り扱い方があります。また、変数の定義も言語によって異なり、変数に値を格納する際の手法も異なります。C#とPythonにおける各データ型の比較や変数の定義方法など、データの取り扱いに焦点を当て、それぞれの特徴や違いについて探ります。このブログ記事の第一回では、このデータの取り扱いに関する基本を詳しく解説します。
  • 処理(第二回)

    処理は変数を介して、順次、選択、反復の組み合わせで記述されます。これらの処理については、第二回の記事で詳しく解説します。
    • 順次： コードは上から下へ順番に実行されます。この順次処理については、インタプリタ言語とコンパイラ言語の違いにも触れながら詳しく取り上げます。
    • 選択：条件によってプログラムが異なる経路を辿る選択処理には、if文などが使われます。条件分岐の仕組みについても詳細に解説します。
    • 反復：特定の処理を繰り返す反復処理には、for文やfor each文などが利用されます。これによって同じ処理を効率的に実行する方法についても説明します。
    第二回の記事では、これらの処理に焦点を当て、それぞれの概念や実装について深堀りしていきます。
  • 部品化と再利用(第三回)

    コードでは同じような処理を行うものを部品として外に出し、再利用できるようにします。これにより、コードがよりメンテナンスしやすくなります。最近ではオブジェクト指向が注目され、それと交えて部品化に関する事項を解説します。第三回の記事では、以下の内容を詳しく取り上げます。
    • 処理の部品化： 類似した処理をメソッドや標準ライブラリ、サードパーティーライブラリなどの形で部品化し、再利用可能な形にする方法について探ります。
    • データ型の部品化：クラスを使用して、データ型を効果的に部品化する手法について解説します。これにより、データ型を再利用可能な形で整理し、拡張性や保守性を向上させることができます。
    第三回の記事では、部品化と再利用の重要性に焦点を当て、実際のコーディングにおいてどのように実現できるかを具体的な例を交えながら紹介します。


データ型

データ型はプログラムにおいて不可欠な要素であり、言語によってその取り扱いが異なります。C#とPythonのデータ型について比較しながら、それぞれの特徴や使い方について紹介します。
  • 整数型：
    • C#: int, uint, short, ushort, long, ulong など複数の整数型が存在します。
    • Python: int 型が整数を表現します。Pythonは動的型付け言語なので、変数宣言時に具体的な型を指定する必要はありません。
  • 浮動小数点型：
    • C#: float, double, decimal が利用可能です。float型を使う場合は最後に f を、decimal型は最後に m を付ける必要があります。
    • Python: float 型が浮動小数点数を表現します。Pythonでは float型の宣言時に f を付ける必要はありませんが、C#と異なり、float型とdouble型の区別はありません。
  • 文字型：
    • C#: char 型が文字を表現します。
    • Python: 文字型は存在せず、文字列型（str）が一文字の文字列を表現します。
  • 文字列型：
    • C#: string 型が文字列を表現します。
    • Python: str 型が文字列を表現します。Pythonの文字列はシングルクォート (') またはダブルクォート (") で囲むことができます。
  • 論理型：
    • C#: bool 型が論理値を表現します。
    • Python: bool 型が論理値を表現します。
      • C#とPythonではデータ型の宣言や使い方が異なりますが、基本的な機能や使い勝手においてはいくつかの類似点もあります。

変数の宣言と代入：C# vs. Python

変数はプログラミングにおいて欠かせない要素であり、C#とPythonでは変数の宣言や代入の仕方が異なります。まずは基本的な概念から見ていきましょう。

コメントアウト：

コード内にコメントを追加することで、他の開発者や自分自身に対して説明やメモを残すことができます。
  
// C#では「//」が行コメント、または/* 複数行コメント */
  

  
# Pythonでは「#」が行コメント


変数宣言とは：

変数宣言は、変数の名前を宣言し、メモリ上に確保することを指します。C#は静的型付き言語であり、変数のデータ型は宣言時に指定する必要があります。一方で、Pythonは動的型付け言語であり、データ型の指定が不要です。

C#の変数宣言と代入：

  
int number; // 整数型の変数を宣言

number = 42; // 変数に値を代入

Pythonの変数宣言と代入：

  
number = 42  # 整数型の変数を宣言と代入を同時に行う

初期値の同時設定：

C#では変数宣言と代入を同時に行うことで、初期値を設定できます。
  
int y = 20; // 変数yを宣言と同時に初期値20で代入

変数の代入と上書き：

どちらの言語も変数は再代入可能です。
    
//C#
int x = 5;  // 変数xに初期値を設定

x = 10;     // 変数xに新しい値を代入
    
  
  
#Python
x = 5  # 変数xに初期値を設定

x = 10  # 変数xに新しい値を代入

注意点：

C#において変数宣言と代入を同時に行うことで、初期値を設定することができます。これにより、変数が未初期化の状態で使用されるエラーを防ぐことができます。しかし、適切に初期値を設定する必要があります。

演算子の比較：C# vs. Python

演算子はプログラミングにおいて数値計算や文字列結合など、さまざまな操作に利用されます。ここではC#とPythonでの演算子の使い方を比較しながら紹介します。

コンソールへの出力：

演算子がどのように使われるかをみるために、まずコンソールへの出力方法を比較しましょう。
    
// C#

Console.WriteLine("Hello, C#!"); // Hello, C#! 
    
  
    
# Python

print("Hello, Python!")  # Hello, Python!
それでは、これらを使って実際にどのように演算子が使われるかをみてみましょう。

基本的な演算子：

    
// C#

int x = 10;
int y = 5;
resultCSharp = x + y; // 足し算
Console.WriteLine(resultCSharp); // 15

resultCSharp2 = x - y; // 引き算
Console.WriteLine(resultCSharp2); // 5

resultCSharp3 = x * y; // 掛け算
Console.WriteLine(resultCSharp3); // 50

resultCSharp4 = x / y; // 割り算
Console.WriteLine(resultCSharp4); // 2

resultCSharp5 = 10 % 3; //割り算の余り
Console.WriteLine(resultCSharp5); // 1

resultCSharp6 = System.Math.Pow(10, 3); //C#にはべき乗ができる演算子はない
Console.WriteLine(resultCSharp6); // 1000


int quotient = 10 / 3; // int型同士の場合、商がintになる

Console.WriteLine(quotient); // 3
    
  
    
# Python

x = 10
y = 5
resultPython = x + y  # 足し算
print(resultPython)  # 15

resultPython = x - y  # 引き算
print(resultPython)  # 5

resultPython = x * y  # 掛け算
print(resultPython)  # 50

resultPython = x / y  # 割り算
print(resultPython)  # 2

resultPython = 10 % 3  # 割り算の余り
print(resultPython)  # 1

resultPython = 10 ** 3  # べき乗
print(resultPython)  # 1000


quotient = 10 / 3  # 割り算

print(quotient)  # 3.3333333333333335 (float型)

キャスト式：

(型名)変数の形で書くことで、型を変えることができます。これを使うと、C#の割り算で小数点以下も求めることができます。
    
// C#

int x = 10;
int y = 3;
double resultWithCast = (double)x / y; // キャストして割り算 (double型同士の場合)

Console.WriteLine(resultWithCast); // 3.3333333333333335
    
  
    
# Python

x = 10
y = 3
resultWithCast = float(x) / y  # キャストして割り算
print(resultWithCast)  # 3.3333333333333335   同じ結果が得られる。

省略演算子：

演算子＝の形で書くことで、ある数ずつ増やしていきたい場合などに簡単に書ける方法が存在します。
    
// C#

int x = 5;

x += 3; // 同義の式：x = x + 3;
Console.WriteLine(x); // 8

//他にも
x -= 3; // 同義の式：x = x - 3;
Console.WriteLine(x); // 5
x *= 3; // 同義の式：x = x * 3;
Console.WriteLine(x); // 15
x /= 3; // 同義の式：x = x / 3;
Console.WriteLine(x); // 5

    
  
    
# Python

y = 5

y += 3  # y = y + 3

print(y)  # 8
y -= 3  # y = y - 3
print(y)  # 5
y *= 3  # y = y * 3
print(y)  # 15
y /= 3  # y = y / 3
print(y)  # 5

インクリメント・デクリメント：

    
// C#

int count = 10;

count++; // count = count + 1;

Console.WriteLine(count); // 11

Console.WriteLine(count++); // 11  表示してから足す

Console.WriteLine(count); // 12

Console.WriteLine(++count); // 13  足してから表示する
count--
Console.WriteLine(count); // 12 デクリメントも存在する
このようなインクリメントやデクリメントはpythonの記法として存在しない。

文字列操作：

    
// C#

string greeting = "Hello";

string name = "John";

int age = 20;

string message = greeting + ", " + name + "!"; // 文字列結合

Console.WriteLine(message); // Hello, John!

string message2 = name + “は” + age + “歳です”;

// 文字列と数字の結合では自動的に文字列として扱ってくれる。

Console.WriteLine(message2); //Johnは20歳です。
    
  
    
# Python

greeting = "Hello"

name = "John"

age = 20

message = greeting + ", " + name + "!" # 文字列結合

print(message) #Hello, John!

#message2 = name + “は” + age + “歳です” #エラー
# Pythonでは、文字列と数字の結合では自動的に文字列として扱ってくれない。
message2 = name + “は” + str(age) + “歳です” #キャストする必要がある。
print(message2) #Johnは20歳です。

文字列への変数の代入

    
//C#

string name = "John";

int age = 20;

Console.WriteLine(message); // Hello, John!

string message3 = $“{name}は{age}歳です”; 

// $文で＋を使わなくても表示してくれる。

Console.WriteLine(message3); //Johnは20歳です。
    
  
    
# Python

name = "John"

age = 20

message3 = f“{name}は{age}歳です”  # f文で＋を使わなくても表示してくれる。

print(message3) #Johnは20歳です。
上記の比較を通じて、C#とPythonで演算子を使った計算や文字列操作がどのように異なるか理解できるでしょう。

文字列の表示：エスケープ文字の利用

プログラミングにおいて、文字列の中に特殊な記号や制御文字を含めたい場合、エスケープ文字が利用されます。たとえば、￥nは改行を示し、￥tはタブを示します。ここではC#とPythonでの文字列表示におけるエスケープ文字の使い方を比較します。

改行やタブなどのエスケープ文字：

    
// C#
string cSharpString = "Hello\nWorld\t!";
Console.WriteLine(cSharpString);
// 出力：Hello
//        World     !
    
  
    
# Python
python_string = "Hello\nWorld\t!"
print(python_string)
# 出力：Hello
#        World     !

バックスラッシュそのものを表現：

    
// C#
string cSharpPath = "C:\\Windows\\System32";
Console.WriteLine(cSharpPath);
// 出力：C:\Windows\System32
    
  
    
# Python
python_path = "C:\\Windows\\System32"
print(python_path)
# 出力：C:\Windows\System32

特殊文字をエスケープしない方法：

    
// C#
string cSharpPathLiteral = @"C:\Windows\System32";
Console.WriteLine(cSharpPathLiteral);
// 出力：C:\Windows\System32
    
  
    
# Python
python_path_literal = r"C:\Windows\System32"
print(python_path_literal)
# 出力：C:\Windows\System32
C#では@を文字列の前に付けることで、バックスラッシュなどのエスケープ文字を無視して文字列をそのまま扱うことができます。同様の機能はPythonにおいても、rを文字列の前に付けることで実現できます。これらの記法は、特にWindowsのファイルパスを扱う場合に便利です。エスケープ文字を気にせずに、そのままの文字列を利用できるためです。

配列の操作：C#とPythonの比較

プログラミングにおいて、データを複数まとめて管理するのに使われる配列。ここでは、C#とPythonにおける配列の基本的な操作について比較してみましょう。

C#での宣言と初期化：

    
// C#
string[] items = new string[3];

Pythonでの宣言と初期化：

    
# Python
items = []
# itemsは空のリスト

C#の配列型と初期化：

C#において、配列型は参照型変数です。単なる宣言だけではnullを参照しています。実際にメモリを確保し、初期化するには以下のように行います。 
    
// C#
string[] items;      //NULL参照している
items = new string[3];    // itemsは["", "", ""]で初期化される

初期値を持たせる場合の初期化：

    
// C#
string[] fruits = { "apple", "orange", "pine" };
// fruitsは["apple", "orange", "pine"]で初期化される
C#では、初期化の際は中括弧の{　}を使用します。

Pythonの初期化：

    
# Python
fruits = ["apple", "orange", "pine"]
# fruitsは["apple", "orange", "pine"]で初期化される
Pythonでは、そのまま[]で代入できます。

値の取り出しと代入：

    
// C#
string firstFruit = fruits[0];
// firstFruitは"apple"になる
fruits[3] = “banana” //４つめはbananaとして代入される。
    
  

    
# Python
first_fruit = fruits[0]
# first_fruitは"apple"になる
fruits[3] = “banana” //４つめはbananaとして代入される。

インデックスの注意点：

ほとんどのプログラミング言語では、インデックスは0から始まります。C#もPythonも例外ではありません。

配列の長さの取得：

    
// C#
int length = fruits.Length;
// lengthは4になる
    
  

    
# Python
length = len(fruits)
# lengthは4になる

定数の取り扱い：C# と Python の比較

プログラム内で変更されてほしくない値やデータを扱うとき、定数が有用です。まず、定数が何かを理解し、C#とPythonでの取り扱いの違いについて見てみましょう。

定数とは：

定数はプログラム内で一貫して同じ値を持つデータに対して使われます。例えば、円周率や税率などがこれに該当します。定数は変数とは異なり、定義時に必ずデータを設定し、以降その内容を変更できません。
    
// C#
const float PI = 3.14159265359;
上記の例では、piは円周率を表す定数で、値は3.14159265359です。この定数はプログラム内で変更できません

C#での定数の使用例：

    
// C#
const float PI = 3.14159265359;
float radius = 5;
float circumference = 2 * PI * radius;
この例では、piは定数として円周率を表し、後で計算に利用されています。 しかし、C#では以下のようにして代入しようとするとエラーが発生します。 
    
// C# - エラーが発生する
PI = 3.14; // 定数 'PI' は変更できません

Pythonにおける定数の扱い：

一方で、Pythonには直接的な定数のキーワードが存在しません。通常の変数と同じように扱われます。 
    
# Python
PI = 3.14159265359
radius = 5
circumference = 2 * PI * radius
PythonではPIを大文字で書くことで、この変数が定数であることを示す慣習があります。しかし、Python自体が厳密な定数を提供しているわけではありません。 C#と異なり、Pythonでは再代入が可能ですが、慣習的に変更しないようにすることが重要です。

型推定と型変換：C# と Python の比較

静的型付き言語と動的型付け言語の違いを理解し、C#とPythonにおける型推定と型変換の違いについて見てみましょう。

C#における型推定：

C#は静的型付き言語であり、変数の型は宣言時に指定する必要があります。ただし、var キーワードを使用することで、代入から型を推定してくれる機能があります。

まず、Random クラスを使用してC#で乱数を生成する方法を見てみましょう。 
    
// C# - 乱数生成
Random dice = new Random(); // Random型のdice変数を宣言
int result = dice.Next(1, 7); // 1から6の範囲で乱数を生成し、resultに代入
このメソッドは新しい Random オブジェクトを作成し、それを利用して乱数を生成します。dice.Next(最小値, 最大値 + 1)の形式で指定された範囲内の整数が生成されます。

Pythonにおける乱数生成：

Pythonでは、標準ライブラリのrandom モジュールを使用して乱数を生成します 
    
# Python - 乱数生成
import random
dice_result = random.randint(1, 6)  # 1から6の範囲で乱数を生成し、dice_resultに代入
Pythonでは、random.randint(最小値, 最大値)が利用されます。random モジュールをインポートする必要があります。

型推定の注意点：

C#のvar キーワードを使用することで型推定が可能ですが、多用するとコード上ですぐに型が判別できないというデメリットがあります。コードの可読性を損なわないように注意が必要です。 
    
// C# - 型推定のデメリット
var value = 42; // 型がすぐには判別しにくい
value の型はintですが、var を使用することで直感的には分かりにくくなります。適切なタイミングや文脈で使うことが重要です。 

    
// C# - 型推定
var dice = new Random();
var result = dice.Next(1, 7); // resultの型はintと推定される
インスタンスでは、そのインスタンスがどんな型であるかはあまり重要ではない場合が多く、型推定は特にインスタンスなどで有用です。

Pythonにおける型推定

Pythonは動的型付け言語であり、変数の型を明示的に指定する必要がありません。代入後は型が自動的に決まります。

C#における型変換：

C#では拡大変換と縮小変換の概念があります。拡大変換は自動で行われますが、縮小変換は明示的な指定（キャスト）が必要です。
    
// C# - 型変換
int intValue = 10;
decimal decimalValue = intValue; // 拡大変換は自動で行われる

decimal decimalNumber = 15.75m;
int intNumber = (int)decimalNumber; // 縮小変換はキャストが必要
文字列変換や数値変換には、.ToString() や int.Parse() などが使用されます。 
    
// C# - 文字列変換と数値変換
int number = 42;
string strNumber = number.ToString(); // 数値から文字列への変換

string numericString = "123";
int parsedNumber = int.Parse(numericString); // 文字列から数値への変換

Pythonでの型変換

Pythonでは型変換が柔軟で、明示的な変換メソッドが用意されています。 
    
# Python - 型変換
int_value = 10
decimal_value = float(int_value)  

decimal_number = 15.75
int_number = int(decimal_number)
文字列変換や数値変換には、str() や int() が使用されます。 
    
# Python - 文字列変換と数値変換
number = 42
str_number = str(number)  # 数値から文字列への変換

numeric_string = "123"
parsed_number = int(numeric_string)  # 文字列から数値への変換
このように、C#とPythonでは型推定や型変換の手法に違いがあります。

コレクションの比較：C# と Python

コレクションはプログラミングで頻繁に使用されるデータ構造で、複数の要素を格納するための便利な手段です。この章では、C#とPythonにおける主要なコレクション型であるリスト型と辞書型に焦点を当て、それらの使い方を比較してみましょう。

リスト型について：

まず、リスト型は配列型とは異なり、長さが可変であり、要素の追加や削除が容易です。

Pythonにおけるリスト型の使用方法：

    
# Python - リスト型の使用例
my_list = [1, 2, 3, 4, 5]  # リストの宣言と初期化
my_list.append(6)  # 要素の追加
my_list.remove(3)  # 要素の削除
print(my_list)  # [1, 2, 4, 5, 6] - 最終的なリストの内容
前の章で扱ったPythonでの配列は、厳密にはリスト型であることがわかると思います。

C#におけるリスト型の使用方法：

    
// C# - リスト型の使用例

List<int> my_list = new List<int> { 1, 2, 3, 4, 5 };  // リストの宣言と初期化
my_list.Add(6);  // 要素の追加
my_list.Remove(3);  // 要素の削除
Console.WriteLine(string.Join(", ", my_list));  // 1, 2, 4, 5, 6 - 最終的なリストの内容
C#では List<T> クラスを使用してリストを実現します。Pythonと同様に、Add() メソッドで新しい要素を追加し、Remove() メソッドで指定した値の要素を削除します。

辞書型について：

辞書型はキーと値のペアを格納するデータ構造です。

Pythonにおける辞書型の使用方法：

    
# Python - 辞書型の使用例
my_dict = {'apple': 3, 'orange': 5, 'banana': 2}  # 辞書の宣言と初期化
my_dict['grape'] = 4  # 新しいキーと値の追加
del my_dict['orange']  # キー 'orange' の削除
print(my_dict)  # {'apple': 3, 'banana': 2, 'grape': 4} - 最終的な辞書の内容
この例では、新しいキーと値の追加は単純な代入で行い、del ステートメントで指定したキーの要素を削除しています。

C#における辞書型の使用方法：

    
// C# - 辞書型の使用例
Dictionary<string, int> my_dict = new Dictionary<string, int>
{
  {"apple", 3},
  {"orange", 5},
  {"banana", 2}
};  // 辞書の宣言と初期化

my_dict["grape"] = 4;  // 新しいキーと値の追加
my_dict.Remove("orange");  // キー 'orange' の削除

foreach (var entry in my_dict)
{
  Console.WriteLine($"{entry.Key}: {entry.Value}");
}
 // 出力: apple: 3, banana: 2, grape: 4 - 最終的な辞書の内容
C#では Dictionary<TKey, TValue> クラスを使用して辞書を実現します。新しいキーと値の追加は同様に単純な代入で行い、Remove() メソッドで指定したキーの要素を削除します。また、foreach 文を使用して辞書の内容を表示しています。

その他のコレクション型：

C#とPythonには他にも多くのコレクション型が存在します。例えば、C#には HashSet<T>（重複なしのコレクション）、Queue<T>、Stack<T>、LinkedList<T> などがあります。Pythonにはさまざまな組み込みコレクションが存在し、必要に応じて選択できます。

コレクションの選択は使用ケースに依存します。データの構造やアクセスパターンに合わせて最適なものを選ぶことが重要です。

まとめ

第一回の記事では、C#とPythonという二つのプログラミング言語を基に、プログラミングの基本的な要素やそれぞれの言語の特徴に焦点を当てました。

まず、C#とは主にゲームエンジンやアプリケーション開発に利用される静的型付け言語であり、Pythonはその汎用性と豊富なライブラリで知られる動的型付け言語です。両者には構文や特性の大きな違いがありますが、それぞれの得意な領域が存在します。

プログラミングにおいて基本的な原則として、データ、処理、部品化と再利用が挙げられ、これらの概念が効果的に組み合わさることで、クリーンでメンテナンスしやすいコードが生まれます。

データに関しては、種類や取り扱い方がポイントであり、処理においては基本的なフローを順次、選択、反復の形で理解しました。また、部品化と再利用においては、関数やクラスを活用してコードの可読性と再利用性を高める手法を紹介しました。

C#とPythonの比較では、データ型、変数宣言、演算子、文字列操作、配列、定数、型推定、コレクションに焦点を当て、それぞれの言語での異なるアプローチを紹介しました。これらの比較を通じて、どちらの言語も独自の特徴があり、状況によって使い分けが求められることを理解しました。

今回の第一回記事ではデータに関して扱いましたので、第二回では処理についてC#とPythonの比較をしていきたいと思います。



参考文献
  1. C#で学ぶプログラミング入門
  2. はじめてのC#入門コース