Pythonの線形データ構造

データ構造のリニアパイソン

---

<center>码好python的每一篇文章.</center>

---

線形データ構造

リニア紹介するこの章の構成：リスト、タプル、文字列は、ByteArrayのバイト。

• リニアテーブル：抽象的な数学的概念は、抽象要素シーケンス、有限数（0または任意の数）の要素の集合です。

  表は、線形シーケンステーブルとリンクテーブルに分けることができます。

• テーブルの順序：メモリに格納された要素の順序集合。リストでは、典型的なシーケンステーブルです。

• リンクテーブル：はい接続かを知るためにお互いにメモリ分散リンクアップに保存されている要素の集合。

  両方の実施のテーブルの場合は、配列内の要素は、追加、削除、変更、およびどのような効果を見る、検索するには：

• 要素を見つけます

  配列表の迅速インデックス番号、及び高い効率によって取得することができる記憶素子に記憶されたデータを順序付けられます。。

  リンクされたテーブルの要素、乏しい効率を得るために一つだけ反復を通じて、ストレージを分散させます。

• 要素を追加します。

  要素は最後に追加された場合にシーケンシャルテーブルについては、全体のデータテーブルには影響するが、要素が最初または途中に挿入されていない、すべての要素は、（大型の背面を並べ替え数百万以上の影響を考えなければなりませんデータの量）。

  リンクテーブルのためにかかわらず、添加元素が他の元素、小さな衝撃に影響を及ぼさないであろう場所の。

• 要素の削除
  、順序テーブルの削除を要素と要素を追加すると、同じ問題を抱えています。
  リンクテーブルのために、あなたは他の要素、小さな衝撃に影響を与えることなく、要素を削除するに関係なく。

• 変更要素
  の要素によって索引付け配列表のは、迅速に高効率にアクセスして変更することができます。

  リンクテーブルのために、その後だけ繰り返し、要素及び非効率を取得することによって修飾することができます。

概要：最高の効率のためのシーケンステーブルを検索し、修正、追加および非効率的な削除。リンクされたテーブルの向かい。

2.内蔵型で使用されるデータ型

2.1数値

• int型の整数

  説明：0を含む整数負の整数、正の整数（···-2、-1,0,1,2、···）。

  x1 = 1
  x2 = 0
  x3 = -1
  print(type(x1), x1)
  print(type(x2), x2)
  print(type(x3), x3)
  
  # 输出结果如下：
  <class 'int'> 1
  <class 'int'> 0
  <class 'int'> -1
  

  INT（）メソッド：数字または文字列を整数、デフォルトのベース= 10に変換することができる、10進と0が返され渡すパラメータを表します。

  x1 = int()
  x2 = int('1')
  x3 = int('0b10',base=2)  #base=2，表二进制，与传入参数类型一致。
  x4 = int(3.14)
  print(type(x1), x1)
  print(type(x2), x2)
  print(type(x3), x3)
  print(type(x4), x4)
  
  # 输出结果如下：
  <class 'int'> 0
  <class 'int'> 1
  <class 'int'> 2
  <class 'int'> 3
  

• ポイント型フロートフローティング
  説明：整数と小数部の組成を、パラメータを渡すことができますint、str、bytes、bytearray。

  x1 = float(1)
  x2 = float('2')
  x3 = float(b'3')
  print(type(x1), x1)
  print(type(x2), x2)
  print(type(x3), x3)
  
  # 输出结果如下：
  <class 'float'> 1.0
  <class 'float'> 2.0
  <class 'float'> 3.0
  

• コンプレックス（複合型）

  説明：実数と虚数部組成、すべての浮動小数点数。

  パラメータを渡すことができint、 str場合2つのパラメータは、パラメータとして実部と虚部の1の前を通過しました。

  x1 = complex(1)
  x2 = complex(2,2)
  x3 = complex('3')
  print(type(x1), x1)
  print(type(x2), x2)
  print(type(x3), x3)
  
  # 输出结果如下：
  <class 'complex'> (1+0j)
  <class 'complex'> (2+2j)
  <class 'complex'> (3+0j)
  

• ブール値（ブール値）

  説明：int型サブクラスとリターンTrueとFalse、0と1に対応します。

  x1 = bool(0)
  x2 = bool(1)
  x3 = bool()
  x4 = 2 > 1
  print(type(x1), x1)
  print(type(x2), x2)
  print(type(x3), x3)
  print(type(x4), x4)
  
  # 输出结果如下：
  <class 'bool'> False
  <class 'bool'> True
  <class 'bool'> False
  <class 'bool'> True
  

2.2配列（配列）

2.2.1リストリスト

説明：リスト要素は、いくつかのオブジェクトとから成る有序可变線形データ構造、括弧の使用は[ ]示しています。

• 初期化

  lst = []  # 空列表方式1
  #或者
  lst = list()  # 空列表方式2
  print(type(lst),lst)
  
  # 输入结果如下：
  <class 'list'> []
  

• 指数

  説明：アクセス要素、時間複雑に（左から右へ）を使用し、正の指数、（右から左へ）、負の屈折率O(1)、高効率の使用。

  データを取得するために一定間隔によると、スライスと呼ばれます。

  正のインデックス：

  0インデックス間隔から開始し、左から右に[0、L -1]、左右のバッグを含んでいません。

  lst = ['a','b','c','d']
  print(lst[0])  # 获取第一个元素
  print(lst[1:2])  # 获取第二个元素,左包右不包，切片
  print(lst[2:])  # 获取第三个元素到最后一个元素，切片
  print(lst[:])  # 获取所有元素，切片
  
  # 输出结果如下：
  a
  ['c']
  ['c', 'd']
  ['a', 'b', 'c', 'd']
  

  負のインデックス：

  右から左へ、-1からインデックスを開始し、区間[ - 長さ-1]

  lst = ['a','b','c','d']
  print(lst[-1])
  print(lst[-2:])
  
  # 输出结果如下：
  d
  ['c', 'd']
  

• お問い合わせ

  インデックス（）メソッド：L.index(value, [start, [stop]]) -> integer

  戻り値インデックスIDは、リストを反復処理するために、時間計算量はO（N）です。

  lst = ['a','b','c','d']
  print(lst.index('a',0,4))  # 获取区间[0,4]的元素'a'的索引id
  
  # 输出结果如下：
  0
  

  注：要素がスローされます見つけることができない場合ValueError。

  方法カウント（）： L.count（値） - >整数

  戻り値、要素の数がリストを反復するように見える、時間複雑度は、O（N）です。

  lst = ['a','b','a','b']
  print(lst.count('a'))
  
  # 输出结果如下：
  2
  

  LEN（）メソッドは：リストの要素の数を返す、時間複雑度はO（1）です。

  lst = ['a','b','c','d']
  print(len(lst))
  
  # 输出结果如下：
  4
  

  注：いわゆるO（n）はO（1）が、対照的に、効率的に大きなデータ尺度としてではないが、効率が低下増加としてデータのサイズを指します。

• 修正

  リストは、リストの要素を変更することが可能で、注文した変数です。

  lst = ['a','b','c','d']
  lst[0] = 'A'
  print(lst)
  
  # 输出结果如下：
  ['A', 'b', 'c', 'd']
  

• 追加

  APPEND（）メソッド：L.append(object) -> None

  テールの付加的な要素は、その場での修正で、Noneを返します。

  lst = ['a','b','c','d']
  lst.append('e')
  print(lst)
  
  # 输出结果如下：
  ['a', 'b', 'c', 'd', 'e']
  

  （）メソッドを挿入しますL.insert(index, object) -> None、

  指定したインデックスに挿入要素オブジェクト、リターンなし。

  lst = ['a','b','c','d']
  lst.insert(0,'A')  # 在索引0位置插入'A',原有的元素全部往后移，增加了复杂度
  print(lst)
  
  # 输出结果如下：
  ['A', 'a', 'b', 'c', 'd']
  

  （）メソッドを拡張します。 L.extend(iterable) -> None

  複数の要素は、オブジェクトが戻りなしに追加の反復の要素であってもよいし、増加させることができます。

  lst = ['a','b','c','d']
  lst.extend([1,2,3])
  print(lst)
  
  # 输出结果如下：
  ['a', 'b', 'c', 'd', 1, 2, 3]
  

  あなたも通じ一覧表示することができます+と*、新しいリストにスプライス。

  lst1 = ['a','b','c','d']
  lst2 = ['e','f','g']
  print(lst1 + lst2)
  print(lst1 * 2)  # 将列表里面的元素各复制2份
  
  # 输出结果如下：
  ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
  

  次のような状況に特別な注意もあります。

  lst1 = [[1]] * 3  # 结果：[[1], [1], [1]]
  print(lst1)
  lst1[0][0] = 10  # 结果：[[10], [1], [1]]，是这样嘛？？
  print(lst1)
  
  # 输出结果如下：
  [[1], [1], [1]]
  [[10], [10], [10]]  # 为什么结果会是这个？请往下看列表复制章节，找答案！
  

• [削除]

  （）メソッドを削除します。L.remove(value) -> None

  削除された要素を見つけるために、見つけるために、左から右にトラバース、返品なし、スローされ見つからなかっませんValueError。

  lst = ['a','b','c','d']
  lst.remove('d')
  print(lst)
  
  # 输出结果如下：
  ['a', 'b', 'c']  # 元素'd'已经被删除
  

  （）メソッドをポップ：L.pop([index]) -> item

  削除末尾の要素をデフォルトでは、インデックスを指定するための要素を削除し、インデックスが範囲外のスローされますIndexError。

  lst = ['a','b','c','d']
  lst.pop()
  print(lst)
  
  # 输出结果如下：
  ['a', 'b', 'c']
  

  clear（）メソッド：L.clear() -> None

  注意のすべての要素の空のリスト。

  lst = ['a','b','c','d']
  lst.clear()
  print(lst)
  
  # 输出结果如下：
  []  # 空列表了
  

• リバース

  （）メソッドを逆：L.reverse()

  リスト逆転の要素は、Noneを返します。

  lst = ['a','b','c','d']
  lst.reverse()
  print(lst)
  
  # 输出结果如下：
  ['d', 'c', 'b', 'a']
  

• シーケンス

  ソート（）メソッド：L.sort(key=None, reverse=False) -> None

  リストの並び替え要素は、デフォルトでは順、逆= Trueの降順に昇順です。

  lst = ['a','b','c','d']
  lst.sort(reverse=True)
  print(lst)
  
  # 输出结果如下：
  ['d', 'c', 'b', 'a']
  

• メンバー操作で

  リストの内側にメンバーかどうかを決定し、その後、真、ノーリターンはFalseを返します。

  lst = ['a','b','c','d']
  print('a' in lst)
  print('e' in lst)
  
  # 输出结果如下：
  True
  False
  

• リストのコピー

  説明：リストのコピーの要素のリストを参照し、コピー、それが深いと浅いコピーに分割することができる二種類のコピー。リストの要素は、私たちが理解できるように、最初のシンプルなタイプに分類リスト、タプル、辞書、クラス、参照型に分類これらのインスタンス（メモリアドレスを参照）、および、数値、文字列、などのオブジェクト。

  例1：これはまあ所属コピーですか？

  lst1 = [1,[2,3],4]
  lst2 = lst1
  print(id(lst1),id(lst2),lst1 == lst2, lst2)  # id() 查看内存地址
  
  # 输出结果如下：
  1593751168840 1593751168840 True [1, [2, 3], 4]
  

  

  明らかに白が同じメモリアドレスにポイントであると言って、すべてのコピーに属していません。

  例2：浅いコピーコピー

  説明：浅いコピー引用类型オブジェクトがコピーではない、アドレスを指すはまだ同じです。

  

  lst1 = [1,[2,3],4]
  lst2 = lst1.copy()
  print(id(lst1),id(lst2),lst1 == lst2, lst2)
  print('=' * 30)
  lst1[1][0] = 200  # 修改列表的引用类型，所有列表都会改变
  print(lst1, lst2)
  
  # 输出结果如下：
  1922175854408 1922175854344 True [1, [2, 3], 4]
  ==============================
  [1, [200, 3], 4] [1, [200, 3], 4]
  

  例3：深いコピーdeepcopy

  説明：のための深いコピー引用类型オブジェクトが別のものにコピーし、アドレスが同じポイントではありません。

  

  import copy
  
  lst1 = [1,[2,3],4]
  lst2 = copy.deepcopy(lst1)
  print(id(lst1),id(lst2),lst1 == lst2, lst2)
  print('=' * 30)  
  lst1[1][0] = 200  # 修改列表的引用类型，不会影响其他列表
  print(lst1, lst2)
  
  # 输出结果如下：
  2378580158344 2378580158280 True [1, [2, 3], 4]
  ==============================
  [1, [200, 3], 4] [1, [2, 3], 4]
  

2.2.2タプルタプル

説明：タプル要素は、複数のオブジェクトで構成されており、有序不可变データ構造、使用括弧を( )表します。

• 初期化

  t1 = ()  # 空元素方式1，一旦创建将不可改变
  t2 = tuple()  # 空元素方式2，一旦创建将不可改变
  t3 = ('a',)  # 元组只有一个元素，一定要加逗号','
  t4 = (['a','b','c'])  # 空列表方式2
  

  注：オブジェクトの唯一の要素が存在する場合、タプルは、必要があり後ろにコンマである,または他のタイプのデータとなります。

• インデックス
  のリストと、あまりない、例えば。

  t = ('a','b','c','d')
  print(t[0])
  print(t[-1])
  # 输出结果如下：
  a
  d
  

• お問い合わせ

  例えばリスト、あまりない、と。

  t = ('a','b','c','d')
  print(t.index('a'))
  print(t.count('a'))
  print(len(t))
  
  # 输出结果如下：
  0
  1
  4
  

• CRUD

  これは、タプルある不可变タイプではなく、CRUD要素オブジェクト。

  しかし、次のシーンへの注意を払います：

  要素オブジェクト（メモリアドレス）が不変、可変タイプタプル。----ここでは、状況の参照型が浮上しています。

  # 元组的元组不可修改(即内存地址)
  t = ([1],)
  t[0]= 100
  print(t)
  # 结果报错了
  TypeError: 'tuple' object does not support item assignment
      
  ############################################
  
  # 元组里面的引用类型对象可以修改（如嵌套了列表）
  t = ([1],2,3)
  t[0][0] = 100  # 对元组引用类型对象的元素作修改
  print(t)
  
  # 输出结果如下：
  ([100], 2, 3)
  

2.2.3文字列

説明：文字列がいくつかの文字で構成されており、有序不可变データ構造、引用符を使用します。

• 初期化
  パターン、単一および二重引用符、3つのマークなどの様々な。

  name = 'tom'
  age = 18
  str1 = 'abc'  # 单引号字符串
  str2 = "abc"  # 双引号字符串
  str3 = """I'm python"""  # 三引号字符串
  str4 = r"c:\windows\note"  # r前缀，没有转义(转义字符不生效)
  str5 = f'{name} is {age} age.'  # f前缀，字符串格式化，v3.6支持
  print(type(str1), str1)
  print(type(str2), str2)
  print(type(str3), str3)
  print(type(str4), str4)
  print(type(str5), str5)
  
  # 输出结果如下：
  <class 'str'> abc
  <class 'str'> abc
  <class 'str'> I'm python
  <class 'str'> c:\windows\note
  <class 'str'> tom is 18 age.
  

• 指数

  例えばリスト、あまりない、と。

  str = "abcdefg"
  print(str[0])
  print(str[-1])
  
  # 输出结果如下：
  a
  g
  

• 接続

  プラス記号の+文字列を複数まとめて、新しい文字列を返します。

  str1 = "abcd"
  str2 = "efg"
  print(str1 + str2)
  
  # 输出结果如下：
  abcdefg
  

  （）メソッドに参加します：S.join(iterable) -> str

  Sは反復処理可能でイテラブルとして、区切り文字列を表す文字列を、結果の文字列を返します。

  str = "abcdefg"
  print('->'.join(str))
  
  # 输出结果如下：
  a->b->c->d->e->f->g
  

• キャラクターを探します

  （）メソッドを探します。S.find(sub[, start[, end]]) -> int

  サブストリングのサブを見つけるために、左から右に、あなたはまた、間隔を指定返します正のインデックスを見つけることができ、リターンは見つけることができません-1。

  str = "abcdefg"
  print(str.find('a',0,7))
  print(str.find('A'))
  
  # 输出结果如下：
  0
  -1
  

  RFIND（）メソッド：S.rfind(sub[, start[, end]]) -> int

  サブサブストリング見つけるために右から左へ、あなたも返します正の指数を見つけ、間隔を指定することができ、リターンは見つけることができません-1。

  str = "abcdefg"
  print(str.rfind('a'))
  print(str.rfind('A'))
  
  # 输出结果如下：
  0
  -1
  

  そこindex()とfind()似ていますが、例外がスローされます見つけることができない、お勧めしません。

  同じようにs.count()あなたも文字の数をカウントすることができます表示されます。

  同様にlen(s)、あなたはまた、文字列の長さをカウントすることができます。

• 分割

  スプリット（）メソッド：S.split(sep=None, maxsplit=-1) -> list of strings

  9月セパレータを表し、デフォルトは空の文字列であり、maxsplit個= -1は、トラバース文字列全体を示し、及びリストを返します。

  str = "a,b,c,d,e,f,g"
  print(str.split(sep=','))
  
  # 输出结果如下：
  ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  

  rsplit（）メソッドは、右から左トラバーサルに、上記とは異なります。

  分割線（）メソッド： S.splitlines([keepends]) -> list of strings

  [OK]を押して、リザーブラインの区切りかどうかを示す文字列、keependsをカットし、最後にリストに戻ります。

  str = "a\nb\nc\r\nd"
  print(str.splitlines())
  print(str.splitlines(keepends=True))
  
  # 输出结果如下：
  ['a', 'b', 'c', 'd']
  ['a\n', 'b\n', 'c\r\n', 'd']
  

  パーティション（）メソッド：S.partition(sep) -> (head, sep, tail)

  左から右の区切りクエリに、それは、第一の面、セパレータ、三重項尾部に分割されるタプルタプルを返します。

  str = "a*b*c*d"
  print(str.partition('*'))
  # 输出结果如下：
  ('a', '*', 'b*c*d')
  

  rpartition（）メソッド：S.rpartition(sep) -> (head, sep, tail)

  道とは違って、それは右から左にあるが、より一般的に使用される、あなたは情報のサフィックスの一部を取得することができます。

  str1 = "http://www.python.org:8843"
  str2 = str1.rpartition(':')
  port = str2[-1]
  print(port)
  

• 置き換えます

  （）メソッドを置き換えます。S.replace(old, new[, count]) -> str

  すべて置換見つけるために、文字列全体を横断し、カウントが交換の数を表し、デフォルトではすべてを交換し、最終的に復帰新的字符串。

  str = "www.python.org"
  print(str.replace('w','m'))  # 返回的是一个新的字符串
  print(str)  # 字符串不可变，保持原样
  
  # 输出结果如下：
  mmm.python.org
  www.python.org
  

• 削除

  ストリップ（）メソッド：S.strip([chars]) -> str

  両端で指定した文字列を削除し字符集chars、デフォルトの空白文字を削除してください。

  str = " * www.python.org  *"
  print(str.strip("* "))  # 去掉字符串首尾带有星号'*' 和 空白' '
  
  # 输出结果如下：
  www.python.org
  

  そこlstrip()とrstrip文字列の左と右の文字セットを削除します。

• 分析の包括

  startsWith（）メソッド：S.startswith(prefix[, start[, end]]) -> bool

  デフォルトでは文字列の先頭文字の接頭辞を指定し、あなたも間隔を指定できますがあるかどうかを判断します。

  str = "www.python.org"
  print(str.startswith('www',0,14))
  print(str.startswith('p',0,14))
  # 输出结果如下：
  True
  False
  

  endsWith（）メソッド：S.endswith(suffix[, start[, end]]) -> bool

  デフォルトでは、接尾辞を使用して、指定した文字列の最後には、また、間隔指定することができるかどうかが決定されます。

  str = "www.python.org"
  print(str.startswith('www',0,14))
  print(str.startswith('p',0,14))
  # 输出结果如下：
  True
  False
  

  str = "www.python.org"
  print(str.endswith('g',11,14))
  # 输出结果如下：
  True
  

• フォーマット

  Cスタイルのフォーマット：

  

  書式文字列（文字列値に対応する）％S、％のD（デジタル値に相当）等を用いても、中間修飾子％03Dに挿入することができます。

  形式の値：オブジェクトのみ、またはタプル辞書であってもよいです。

  name = "Tom"
  age = 18
  print("%s is %d age." % (name,age))
  # 输出结果如下：
  Tom is 18 age.
  

  フォーマットフォーマット：

  

  書式文字列：ブレース改質剤を使用することができる括弧{}を、使用。

  フォーマットの値：*引数変数の位置パラメータ、** kwargsからキーワードは、変数のパラメータです。

  # 位置传参
  print("IP={} PORT={}".format('8.8.8.8',53))  # 位置传参
  print("{Server}: IP={1} PORT={0}".format(53, '8.8.8.8', Server='DNS Server'))  # 位置和关键字传参传参
  
  # 输出结果如下：
  IP=8.8.8.8 PORT=53
  DNS Server: IP=8.8.8.8 PORT=53
  

  # 浮点数
  print("{}".format(0.123456789))
  print("{:f}".format(0.123456789))    #  小数点默认为6位
  print("{:.2f}".format(0.123456789))  # 取小数点后两位
  print("{:15}".format(0.123456789))   # 宽度为15，右对齐
  
  # 输出结果如下：
  0.123456789
  0.123457     # 为什么是这个值？大于5要进位
  0.12
      0.123456789  # 左边有4个空格
  

• 他の一般的に使用される機能

  str = "DianDiJiShu"
  print(str.upper())  # 字母全部转化为大写
  print(str.lower())  # 字母全部转化为小写
  
  # 输出结果如下：
  DIANDIJISHU
  diandijishu
  

2.2.4バイトバイト

bytes そして、bytearrayのpython3から導入された2つのデータ型。

コンピュータの世界では、機械である0と1、私たちはこのコーディング呼び出す通信するためにも、バイナリ（バイト）として既知の組成、ASCIIコーディング。

だから、コミュニケーションの機械語は、機械語と呼ばれています。しかし、私たち人間は、マシンと通信したい、あなたはそれを行う方法に必要ですか？

• （ASCIIコードの文字列に変換）通常エンコードと呼ばれる機械可読言語に人間の言語をコードします。
• 機械語の人間が読める言語をデコードし、しばしば呼ばれるデコーディング（ASCIIコードでは、文字列に変換しました）。

これまでのところ、エンコードプロセスの近代史は、おそらくこれです：ASCII（1バイト） - >ユニコード（2〜4バイト） - > UTF8（1 _{6バイト）、UTF8はマルチバイトエンコーディング、一般的な使用であり、1} 3バイト、特定の用途の4バイト（典型的には中国語を使用して3バイト）、ASCII符号化との下位互換性。

中国はまた、独自のコーディングを持っている：GBK

使用ASCIIコード表（セクション仕上げ）心に留めておく必要があります。

詳細ASCIIコードのダウンロードリンク：

链接：https://pan.baidu.com/s/1fWVl57Kqmv-tkjrDKwPvSw 提取码：tuyz

したがって、機械は16進数バイトで、1つのバイトは、例えば、8に等しく、バイナリと16進数で小数点以下2、。

# 二进制
0000 0010  # 一个字节bytes

# 16进制，机器基本都是显示16进制
0x2

バイト不変です

bytes()     # 空bytes，一旦创建不可改变
bytes(int)  # 指定字节的大小，用0填充
bytes(iterable_of_ints)  # [0.255]整数的可迭代对象
bytes(string, encoding[, errors])  # 等价于string.encoding(),字符串编码成字节
bytes(bytes_or_buffer)  # 复制一份新的字节对象

• 初期化

  b1 = bytes()
  b2 = bytes(range(97,100))
  b3 = bytes(b2)
  b4 = bytes('123',encoding='utf-8')
  b5 = b'ABC'
  b6 = b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode('utf-8')
  print(b1, b2, b3, b4, b5, b6, sep='\n')
  
  # 输出结果如下：
  b''
  b'abc'
  b'abc'
  b'123'
  b'ABC'
  你好
  

2.2.5のByteArrayバイト配列

BYTEARRAY可変配列、付加および欠失は、類似のリストを操作することができます。

bytearray()  # 空bytearray,可改变
bytearray(iterable_of_ints)  # [0.255]整数的可迭代对象
bytearray(string, encoding[, errors])  # 等价于string.encoding(),字符串编码成字节
bytearray(bytes_or_buffer)   # 复制一份新的字节数组对象
bytearray(int)  # 指定字节的大小，用0填充

• CRUD

  # 初始化
  b = bytearray()
  print(b)
  # 输出结果如下：
  bytearray(b'')
  #--------------------------
  # 增加元素对象
  b.append(97)
  print(b)
  b.extend([98,99])
  print(b)
  # 输出结果如下：
  bytearray(b'a')
  bytearray(b'abc')
  #--------------------------
  # 插入元素对象
  b.insert(0,65)
  print(b)
  # 输出结果如下：
  bytearray(b'Aabc')
  #--------------------------
  # 删除元素对象
  b.pop()
  print(b)
  # 输出结果如下：
  bytearray(b'Aab')
  

今日はこれに行って、我々は次のラウンドLaokeを踏襲set (集合) し、dict (字典)あなたの忍耐に感謝します。

---

もし私の記事のような場合、私は公共の数の関心を歓迎：ドリップ技術、関係するスキャンコード、随時共有に