第III章データ型

第III章データ型

3.1整数（int型）

当然の負の整数を含む任意のサイズの整数、

>>> 100
100
>>> -9999
-9999
>>>

3.1.1整数の長さ

python2：

• 32ビットマシン上で、ビットの整数を32ビットの範囲であり、-231〜231-1、即ち-2147483648 2147483647
• 64ビットシステムで、の範囲内の整数用64ビット-263〜263-1、すなわち-9223372036854775808〜9223372036854775807
• 長さを超えた後、ロングタイプとなります

python3：

• INTが長いだけ、すべての数値はint型ですではありません。

3.1.2割り切れます

python2部門で使用する場合、モジュールに導入されるように、小数点以下を保持したい場合は、整数ビットは、保持することができます。

>>> from __future__ import division
>>> value = 3/2
>>> print(value)
1.5
>>>
>>> value = 10/3
>>> print(value)
3.33333333333

3.2ブール（ブール値）

値の唯一のブール値はTrue、Falseの2種類が、真または偽のいずれかであります

真と偽を表すのに使用されるブール値。TrueとFalse。

>>> True
True
>>> 3 > 2
True
>>> False
False
>>> 3 > 5
False
>>> 30 > 66
False
>>> 444 > 333
True
>>>

ブール値に変換し、他のタイプ：

• STR
• ...

以下の場合：なし/ "" / 0 .... - >偽

3.3文字列（文字列）

Unicodeのコード格納：文字列はPythonのメモリストリングは、に従っている、最も一般的な書き込みコードです。文字列の場合は不変です。

3.3.1文字列の連結

ルールを追加する文字列の連結は、ある必要文字列で合計に

>>> a = "hello"
>>> b = "word"
>>> print(a+b)
helloword

3.3.2文字列掛け

複数のストリングを掛けると縫い合わせ文字列、乗算ルールです：唯一の文字列と数値を乗算され、

>>> a = "hello"
>>> b = 5
>>> print(a*b)
hellohellohellohellohello

• ストリングは、減算及び除算することはできません

3.3.3インデックス

左から0から始まるコード化された右の注文に文字列の各要素のインデックスは、各文字列の最初の要素のインデックスは0です。

インデックスが負で、右から左への除去要素、0に等しいので-0、-1、右から左への最初の要素を表す場合

• 例

>>> name = "ABCDE"
>>> print(name[0])
A
>>> print(name[1])
B
>>> print(name[2])
C
>>> print(name[-1])
E
>>> print(name[-2])
D
>>> print(name[-0])
A

3.3.4スライス

中間マストセミコロン：スライスは、[第二の位置は終了する最初の開始位置]、特定のインデックスの列によって取り出されます。

デフォルトのインデックスを取得したコンテンツの終了には含まれていません

• 例

>>> name = "ABCDE"
>>> print(name[:1])
A
>>> print(name[1:])
BCDE
>>> print(name[1:4])
BCD
>>> print(name[1:-1])
BCD
>>> print(name[1:-2])
BC

3.3.5ステップ

カッコ内の最初のパラメータは、開始位置であり、2番目のパラメータは端位置で、今、あなたに伝えるために3番目のパラメータはステップサイズ（各数歩の距離）であります

>>> name = "ABCDE"
>>>
>>> print(name[:1:2])
A
>>> print(name[::2])
ACE
>>> print(name[::-2]) # 负数就是倒着取
ECA
>>>

3.3.6文字列メソッドのコメント

[補足]大文字、フリップケース（特殊文字と数字）で区切られた各単語を大文字

 s = 'alex Wusir' #首字母大写
 s1 = s.capitalize()  #首字母大写# print(s1) #Alex wusir

 s3 = s.swapcase() #大小写翻转
 print(s3) #ALEX wUSIR

 a = 'zhangyang zy yy'
 a1 = a.title() #每个隔开的（特殊字符和数字）单词首字母大写
 print(a1) #Zhangyang Zy Yy

1. ALL）は、（上部CAPS

• 例

>>> name = 'abcdef'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF

#######

>>> name = 'ABCdef123'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF123
>>>
##################
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)

2.すべて小文字下（）

• 例

>>> name = 'ABCDEF'
>>> new_name = name.lower()
>>> print(new_name)
abcdef

################

>>> name = 'ABCdef123'
>>> new_name = name.lower()
>>> print(new_name)
abcdef123

3.別の文字列（置き換え）

古い文字列の（）メソッドを置き換える（古い文字列）新しい（新しい文字列）に置き換えられ、第三引数最大、最高の交換回数以上でない場合

• （）メソッドの構文を置き換えます：

str.replace(old, new[, max])

• パラメータ

old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

• 例

message = input('请说话：')
print(message)
data = message.replace('大爷',"**",2)# 将大爷替换成**，替换不超过2次
print(data)

4.）（キャラクターテープをはがし

• ストリップ（）構文

str.strip([chars])

• パラメータ

chars 代表要去除的字符，默认是空格

ストリップは、（）頭と尾の除去です。

• 例

name = '  AB, CD, E, F,  G  '
new_name = name.strip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G <---

lstrip（）左側の文字を削除することです

• 例

name = '  AB, CD, E, F,  G  '
new_name = name.lstrip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G   <---

rstrip（）右側の文字を削除することです

• 例

name = '  AB, CD, E, F,  G  '
new_name = name.rstrip()
print("--->",new_name,"<---")
--->   AB, CD, E, F,  G <---

文字切断分割（）

指定された文字列の区切り文字によってスライス

• スプリット（）構文：

str.split(分隔符, 分割次数)

スプリット（）を右へ左からカット

rsplit（）右から左に切ります

• 例

>>> message = "小黑现在一脸懵逼，因为昨天晚上一直在学习，直到深夜。"
>>> result = message.rsplit('，',1)
>>> print(result)
['小黑现在一脸懵逼，因为昨天晚上一直在学习', '直到深夜。']
>>> result = message.rsplit('，')
>>> print(result)
['小黑现在一脸懵逼', '因为昨天晚上一直在学习', '直到深夜。']

6デジタルかどうかを決定する：isdecimal / .isdigit（）

v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit()  # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是 10进制的数。

# ############## 应用 ##############

v = ['alex','eric','tony']

for i in v:
    print(i)

num = input('请输入序号：')
if num.isdecimal():
    num = int(num)
    print(v[num])
else:
    print('你输入的不是数字')

7.何.startswith（）で開始します

name = 'AB, CD, E, F,G  '
new_name = name.startswith("A")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G  '
new_name = name.startswith("a")
print("--->",new_name,"<---")
---> False <---

8.）（何最後まで.endswithです

name = 'AB, CD, E, F,G'
new_name = name.endswith("G")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G'
new_name = name.endswith("g")
print("--->",new_name,"<---")
---> False <---

9.フォーマット出力.format（）を

name = 'AB, CD, E, F,G,{}'
new_name = name.format("呵呵呵")
print("--->",new_name,"<---")
---> AB, CD, E, F,G,呵呵呵 <---

10.接続文字列.join（）

name = 'AB, CD, E, F,G'
new_name = "_".join(name)
print("--->",new_name,"<---")
---> A_B_,_ _C_D_,_ _E_,_ _F_,_G <---

11.統計数字.count（）

name = 'AB, CD, E, F,G,ABC,AC'
new_name = name.count("A")
print("--->",new_name,"<---")
---> 3 <---

12.符号化フォーマット指定.encode（）

name = 'ABCDEF'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
#######################
name = 'ABCDEF'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
######################
name = '努力'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'\xe5\x8a\xaa\xe5\x8a\x9b' <---
######################
name = '努力'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'\xc5\xac\xc1\xa6' <---

3.4リスト（一覧）

Pythonリストは、[]で囲まれている基礎となるデータ・タイプの一つであり、各要素「」離間及び各種データを格納することができます。

例えば：

lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]

3.4.1。インデックスのリスト

リストには、インデックスがあります。

>>> lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0])
alex
>>> print(lis[1])
WuSir
>>> print(lis[2])
ritian
>>> print(lis[3])
barry

3.4.2。スライスリスト

リストには、インデックスに応じてスライスすることができます

lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0:3])
['alex', 'WuSir', 'ritian']
>>> print(lis[0:-1])
['alex', 'WuSir', 'ritian', 'barry']
>>> print(lis[1::2])
['WuSir', 'barry']
>>>

3.4.3ネストされたリスト

>>> lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
>>> print(lis[3])
['qwe', 20, ['k1', ['tt', 3, '1']], 89]
>>> print(lis[3][2])
['k1', ['tt', 3, '1']]
>>> print(lis[3][2][0])
k1
>>> print(lis[3][2][1])
['tt', 3, '1']

メソッドの詳細なリストを3.4.4

1.追加.append()

user_list = ["alex","wusir","ritian","jing"]
user_list.append("摸摸哒")
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒']

2.挿入.insert（）

user_list = ["alex","wusir","ritian","jing"]
user_list.insert(0,"摸摸哒")
print(user_list)
['摸摸哒', 'alex', 'wusir', 'ritian', 'jing']

3. [削除]インデックス.pop（）

user_list = ["alex","wusir","ritian","jing"]
user_list.pop(3)
print(user_list)
['alex', 'wusir', 'ritian']

4.）（内容によって.remove削除

user_list = ["alex","wusir","ritian","jing"]
user_list.remove("alex")
print(user_list)
['wusir', 'ritian', 'jing']

5.クリアリスト.clear（）

user_list = ["alex","wusir","ritian","jing"]
user_list.clear()
print(user_list)
[]

6.del（指数によると、あなたはセクションを削除することができます削除します）

a = ['kngiht','kevin','qaz',1,2,3]
del a[2:4]
print(a)     #['kngiht', 'kevin', 2, 3] 按索引切片删除

7.反復添加.extend（）

user_list = ["alex","wusir","ritian","jing"]
user_list.extend(["摸摸哒","呵呵哒","佩琦"])
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒', '呵呵哒', '佩琦']

8.逆コンテンツリスト.reverse（）

user_list = ["alex","wusir","ritian","jing"]
user_list.reverse()
print(user_list)
['jing', 'ritian', 'wusir', 'alex']

9.（.sort並べ替え）

## 正向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort()
print(user_list)
[1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 6, 16, 20, 100]

## 反向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort(reverse=True)
print(user_list)
[100, 20, 16, 6, 5, 5, 5, 4, 4, 3, 3, 2, 2, 1]

3.5元グループ（タプル）

不変のリスト、およびリストは読み取り専用で、タプルの基本データ型のいずれかのpythonているされ、任意のデータ型を置くことができる小さなブラケットと、クエリはまた、環状であってもよい、スライスしてもよいが、それを変更することはできません。

>>> lis = ("alex", "WuSir", "ritian", "barry", "wenzhou")
>>>
>>> print(lis[0])
alex
>>> print(lis[1:4])
('WuSir', 'ritian', 'barry')
>>> print(lis[1:])
('WuSir', 'ritian', 'barry', 'wenzhou')
>>> print(lis[1:-1])
('WuSir', 'ritian', 'barry')
>>> print(lis[::-1])
('wenzhou', 'barry', 'ritian', 'WuSir', 'alex')
>>>

不変、注意について：このタプルは不変で不変サブ要素およびサブ要素内のサブ要素は子要素が可変オブジェクトであるかどうかに応じて、変更することができる手段です。

タプルのみの一つの要素。、カンマを追加してくださいが、それ以外の場合はタプルでない場合

>>> tup = ("keep")
>>> print(type(tup)) # type是查看数据类型
<class 'str'>
>>> tup = ("keep",)
>>> print(type(tup))
<class 'tuple'>

元祖のネスト

>>> tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱',' 小姨子低声说道说和姐夫还提钱'))
>>>
>>> print(tu1)
今天姐姐不在家
>>> print(tu2)
姐夫和小姨子在客厅聊天
>>> print(tu3)
姐夫问小姨子税后多少钱
>>> print(tu4)
小姨子低声说道说和姐夫还提钱

タプル（不変）

• 公衆
  • 指数
  • 薄切
  • ステップ
  • にとって
  • のみ

3.6辞書（辞書）

ディクショナリ（辞書）はパイソン⼀型マッピングで⼀だけである。彼は、{}のキーと値のペアで囲まれています。

そして、リストの比較のリストは、辞書dictのは、次の特性があります。

1. 検索と高速を挿入し、キーを遅く増加しません。
2. これは、メモリ、メモリおよびより廃棄物の多くを取ります。

反対のリスト：

1. 要素の増加を増加させ、時間を見つけて、挿入します。
2. 小さなフットプリント、廃棄物が非常に少ないメモリ。

キーにキーに従って保存され、⼀算出したメモリアドレスにのみ辞書⼀である。キー値は、このアドレスに格納され、このアルゴリズムは、ハッシュアルゴリズムと呼ばれています。

ハッシュされていない変更することができ、ハッシュは、それを変更することはできませんを意味します。これは、正確にメモリアドレス⽽規定を計算するためにあります。

3.6.1構文

{'key1':1,'key2':2}

注意：。キーは不変（ハッシュ可能）でなければならない値を保存することができる任意のタイプのデータを必要としません。

データ分類：変数のデータ型、データ型不変

順序なし辞書

不可变数据类型：元组,bool,int str  -->可哈希
可变数据类型：list,dict,set      --> 不可哈希
dict key(键) 必须是不可变数据类型(可哈希)    value(值)：任意数据类型

3.6.2メソッド辞書

1.増加

dic = {'age':18,'name':'jin','sex':'male',}
1.1
dic['hight']=180 # 没有键值对会新增
print(dic)#{'age': 18, 'name': 'jin', 'sex': 'male', 'hight': 180}
dic['age']=16 #如果有键，则值会覆盖
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180}

1.2
dic.setdefault('weight') #有键值对，不做任何改变，没有则添加
dic.setdefault('weight',150)
dic.setdefault('name','erge')
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}

2.削除

2.1 pop
print(dic.pop('age'))#16   返回age对应的值
print(dic.pop('二哥',None)) #None  为了防止删除的时候没有要删除的键，而报错设置一个返回值，也可以是字符串'没有此键'
print(dic.pop('name',None)) #jin 删除有的键，即使设置了返回值None也不会返回，而是返回删除成功的值 jin
print(dic) #{'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}

2.2 popitem
print(dic.popitem()) #随机删除一个元素，并把删除元素的键和值放在一个元组里返回:(key, value)。
#返回值 ('weight', None)
print(dic) #{'sex': 'male', 'hight': 180}
2.3 del
del dic['sex'] #del +键，按键来删除
print(dic) #{'hight': 180}

del dic #删除字典
print(dic)

2.4 clear 清空字典
dic.clear(dic)
print(dic)

3.変更

3.1
dic['age']=16 #如果有键，则值会覆盖

3.2
dic = {'name':'zy','age':18,'sex':'male'}
dic2 = {'name':'alex','weight':'150'}
dic2.update(dic) #一样的键，值会覆盖，不一样的键,会新增
print(dic2) #{'name': 'zy', 'weight': '150', 'age': 18, 'sex': 'male'}

4.クエリ

dic1 = {'name':'zy','age':18,'sex':'male',}
4.1
print(dic1.keys()) #dict_keys(['name', 'age', 'sex'])
print(dic1.values()) #dict_values(['zy', 18, 'male'])
print(dic1.items()) #dict_items([('name', 'zy'), ('age', 18), ('sex', 'male')])


print(dic1['name']) #返回值 zy
print(dic1['name1']) #会报错，找不到这个键 KeyError: 'name1'
4.2
#这时可以用dic1.get() 设置一个返回值  如下：
print(dic1.get('name1','没有这个键')) #没有这个键

用循环查询
for i in dic1: #dic1与dicdic1.keys()一样,只打印出键
    print(i)  #name age sex

for i in dic1.keys():  #name age sex
    print(i)

for i in dic1.values():
    print(i) #zy 18 male

for i in dic1.items():  #返回的是元组，元组里是键值对
    print(i) #('name', 'zy') ('age', 18) ('sex', 'male')

1. .LEN算出長さ（）

dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
items_dic = dic.update({"悟空":"金箍棒"})
print(len(dic))
4

3.6.3ネスティング辞書

>>> dic = {
...     'name':'汪峰',
...     'age':48,
...     'wife':[{'name':'国际章','age':38}],
...     'children':['第一个熊孩子','第二个熊孩子']
... }
>>>
>>>
>>> d1 = dic['wife'][0]['name']
>>> print(d1)
国际章
>>> d2 = dic['children']
>>> print(d2)
['第一个熊孩子', '第二个熊孩子']
>>> d3 = dic['children'][0]
>>> print(d3)
第一个熊孩子

3.7コレクション（セット）

セットセットは⼀基本データ型のパイソンである。いつものようにシュートが非常に頻繁に使用されない。要素の集合である省略する。⽆配列。⾥要素はハッシュするための画面（不変データ型）でなければなりません

3.7.1収集方法

1.（.add追加）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.add("蔡徐坤")
print(s1)
{'刘能', '蔡徐坤', '⽪⻓⼭', '赵四'}

2.（.discard削除）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.discard("赵四")
print(s1)
{'刘能', '⽪⻓⼭'}

3.交差.intersectionを（）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.intersection(s2)
print(s)
{'⽪⻓⼭'}

そして、4セット.union（）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.union(s2)
print(s)
{'赵四', '冯乡⻓', '刘能', '⽪⻓⼭', '刘科⻓'}

5.差集.difference（）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.difference(s2)
print(s)
{'赵四', '刘能'}

##################

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.difference(s1)
print(s)
{'冯乡⻓', '刘科⻓'}

6.アンチ交差点.symmetric_difference（）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.symmetric_difference(s1)
print(s)
{'赵四', '刘能', '冯乡⻓', '刘科⻓'}

7.計算長.LEN（）

s1 = {"刘能", "赵四", "⽪⻓⼭"}
print(len(s1)) #3

3.7.2ネストされた問題

1. # 1. 列表/字典/集合(可变数据类型) -> 不能放在集合中、不能作为字典的key（unhashable）
   # 数据类型划分：可变数据类型,不可变数据类型
   # 不可变数据类型：元组,bool,int str  -->可哈希
   # 可变数据类型：list,dict,set      --> 不可哈希
   
   # info = {1, 2, 3, 4, True, "国风", None, (1, 2, 3)}
   # print(info)
   # 2. hash -> 哈希是怎么回事？
   # 因为在内部会将值进行哈希算法并得到一个数值（对应内存地址），以后用于快速查找。
   
   可使用的对象包括： 数字 、字符串、元组，不可使用hash函数的是 列表、字典。
   hash的特征：hash值的计算过程是以依据这个值的特征计算的，这要求被hash的值必须固定，因此被hash的值必须不可变。
   用途: 文件签名 、 md5加密 、 密码验证
   # 3. 特殊情况
   # info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}  #False为0，与0重复
   # print(info)
   
   # info = {            
   #     1:'alex',
   #     True:'oldboy'
   # }
   # print(info)  #{1: 'oldboy'}
   

3.8パブリック・ファンクション

• のみ
• 指数
• 薄切
• ステップ
• forループ

3.9メモリ関連

3.9.1 ID、メモリアドレスを参照してください

>>> v1 = [11,22,33]
>>> v2 = [11,22,33]
>>> print(id(v1),id(v2)) # 比较两个变量的内存值
4472652360 4473773640   
# 对于 -5 ~ 256 的整数来说会有小地址池的概念，不会创建新的内存地址

>>> v1 = "我，你，他，它，她"
>>> v2 = "我，你，他，它，她"
>>> print(id(v1),id(v2))
4473666128 4473665840

 # 赋值，就是把v2指向了v1的内存地址，所以他们的内存地址一样
>>> v1 = "我，你，他，它，她"
>>> v2 = v1 
>>> print(id(v1),id(v2))
4473666128 4473666128

# 重新赋值，v1的内存地址变了，但是v2的内存地址没变
>>> v1 = "我，你，他，它，她"
>>> v2 = v1    
>>> v1 = "我，你，他，它，她，天"   v1现在指向"我，你，他，它，她，天"的地址，v2还是原来的
>>> print(id(v1),id(v2))
4473665840 4473666128
>>> print(v2)
我，你，他，它，她

で、メモリアドレスを比較します

>>> v1 = {'k1':'v1','k2':[1,2,3]}
>>> v2 = {'k1':'v1','k2':[1,2,3]}
>>> result1 = v1 == v2
>>> result2 = v1 is v2
>>> print(result1)
True
>>> print(result2)
False

重要

違いがあると==しますか？

==平等の値を比較します。
メモリアドレスが等しい比較するために使用されます。

PS：メモリアドレスを見つけ、どの操作と代入と同じでありません

割り当ては、再オープンするメモリ空間の一部である、変数のデータ型を

#练习1(内部修改)
v1=[11,22,33]
v2=v1
v1.append(666)
print(v2) #含有666

#练习2(赋值)
v1=[11,22,33]
v2=v1
v1=[1,2,3,4] #此时v1重新赋值为[1,2,3,4]，v1=[11,22,33] 对应的内存地址被回收，只要有指向这个内存地址的，就不会被回收
print(v2) #[11,22,33]

#练习3(重新赋值) 
v1='alex'
v2=v1
v1='old boy'
print(v2) #'alex'

总结：可变数据类型列表/字典/集合 有内部修改和赋值
字符串等不可变的 只有重新赋值（不可在内部修改）

ps:
v=[1,2,3]
value=[11,22,v]
value[2]=666 #对value自己更改，v不会改变
print(v)  #[1, 2, 3]

v=[1,2,3]
value=[11,22,v]
value[2][0]=666 #对v里面修改，v会改变
print(v)  #[666, 2, 3]

データの小さなプールでのpython - キャッシュメカニズムは、メモリを節約するには

1. デジタル（-5-256）
2. 単純な文字列「ALEX」

a=1
b=1
print(id(a),id(b)) #496846480 496846480  #理论上赋值，是重新开辟内存地址，但python中有缓存机制

3.10コピー深さ

シャローコピー：第一層の唯​​一のコピー

ディープコピー：（唯一の変数のデータ型の）すべてのデータをコピー---再コピーは、メモリ内のスペースを再開く意味します

一つだけ少し深いコピーの意義、それは営巣のために重要です

1、int+str+bool/tuple 深浅拷贝是一样的（不可变数据类型，类似小数据池的概念）

v1='alex'
v2=copy.copy(v1)
v3=copy.deepcopy(v1)
print(id(v1),id(v3)) #11611168 11611168

2、list+set+dict （可变数据类型）
深浅拷贝不一样的

概要

浅拷贝:仅会拷贝a的框架的内存地址, 里面的任何子元素的内存地址都不会被拷贝.
深拷贝:不仅拷贝a的框架,而且会拷贝a里所有的可变元素的内存地址,注意不可变元素仍不可拷贝

3.11型変換

1.デジタル - 文字列

>>> v1 = 666
>>> v2 = str(v1)
>>> print (v2)
666

2.デジタル革命のブール

>>> v1 = 0
>>> v2 = bool(v1)
>>> print (v2)
False
#######################
>>> v1 = 666
>>> v2 = bool(v1)
>>> print (v2)
True

ゼロ以外の値がブールTrueの場合、0がFalseブールターンで転送され、

3.文字列 - デジタル

>>> v1 = "666"
>>> v2 = int(v1)
>>> print (v2)
666
### 字符串内容是数字时，可以转换成数字

>>> v1 = "hello2"
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'hello2'
###字符串含有数字以外的字符时，不能转换成数字


>>> v1 = ""
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
    
###空字符串不能转换成数字

4.文字列ブールターン

>>> v1 = "66q3"
>>> v2 = bool(v1)
>>> print(v2)
True
### 非空字符串转换布尔值都是True

>>> v1 = ""
>>> v2 = bool(v1)
>>> print(v2)
False
### 空字符串转换布尔值是Fales

変換されたデジタルブール

>>> v1 = True
>>> v2 = int(v1)
>>> print(v2)
1

>>> v1 = False
>>> v2 = int(v1)
>>> print(v2)
0

6.ブール値文字列

>>> v1 = True
>>> v2 = str(v1)
>>> print(v2)
True

>>> v1 = False
>>> v2 = str(v1)
>>> print(v2)
False