数据类型与变量

大纲

• 前言
• 基本数据类型
  • 数字(Number)
  • 字符串(String)
  • 列表(List)
  • 元组(Tuple)
  • 字典(Dictionary)
  • 集合(Set)
  • 可变与不可变类型
• 再论变量
  • 多个变量赋值
  • 变量的命名法
• 总结

前言

python各种基本数据类型就相当于厨房里的柴米油盐，只要我们用溜了，米其林大厨也不在话下
一大波概念正在接近，不要被吓怕，我们阳光足、豌豆射手够猛

基本数据类型

数字(Number)

在python中，数字(number)分为四类:

1. 整型(integer)，其实就是整数，例如 520
2. 浮点型(float)，其实就是小数，例如圆周率 3.1415926
3. 布尔值(boolean)，布尔值就是真假值，它有且只有两个值 真True 与 假False，您可以把True和False想象成两个变量，他们的值分别为 1 和 0
4. 复数(complex)，用的很少，例如 1+2j

例子

a = 520 # 整型
b = 3.1415926 # 浮点型
c = True # 布尔值
d = 1+2j # 复数

# 您可以用python内置函数type来查看一个变量指向的类型
print(type(a)) # <class 'int'> int是integer的简写
print(type(b)) # <class 'float'>
print(type(c)) # <class 'bool'> bool是boolean的简写
print(type(d)) # <class 'complex'>

常用数值运算

>>> 1 + 1 # 加法
2

>>> 3 - 1.5 # 减法
1.5

>>> 2 * 5 # 乘法
10

>>> 10 / 3 # 除法, 注意无论是否能整除，得到的都是一个浮点数
3.3333333333333335

>>> 10 / 5
2.0

>>> 10 // 5 # 两个斜杠来表示整除，这样会得到一个整数
2

>>> 10 % 3 # 百分号表示取余运算
1

>>> 2 ** 3 # 两个星号表示乘方运算，这里表示2的3次方
8

注意，如果您以整数与浮点数作运算，那么会得到一个浮点数

>>> 1 + 1.0
2.0

如果您之前学过某种编程语言，您可能会疑惑，布尔值是数字类型？
是的，在python3中， True和False都是其保留字，它们值还是1和0，可以与数字相加

不信来试试

>>> 1 + True
2

>>> True + True # 1 + 1 = 2
2

>>> False == 0 # False等于数值0
True

>>> type(True) # True是bool类的一个实例
<class 'bool'>

>>> issubclass(bool, int) # bool类是int类的子类，内置方法issubclass用于查看一个类是否为另一个类的子类
True

>>> bool.__base__ # bool类是int类的子类，__base__是魔法属性，其指向父类
<class 'int'>

>>> isinstance(True, int) # True是int类的实例，内置方法isinstance用于查看一个值是否为某个类的实例
True

如果上面的示例不太懂，没关系，只需要知道True或False就是数字1和0，它们可以与数字进行运算就可以了

字符串(String)

从HelloWorld程序开始，我们就已经接触过字符串(string)了，现在重新回顾一下，就像偶然在街上遇见一个好久未见的旧朋友，必须要啤酒撸串走一转加深感情一样

字符串可以用四种方法来表示:

1. 用单引号 ' 括住表示
2. 用双引号 " 括住表示
3. 用三个单引号 ''' 括住表示(多行字符串、多行注释)
4. 用三个双引号 """ 括住表示(多行字符串、多行注释)

例子

# 单个单引号表示
a = '你真帅'

# 单个双引号表示
b = "你真漂亮"

# 三个单引号表示多行字符串
c = '''你怎么
这么好看'''

# 三个双引号表示多行字符串
d = """是天生的吗
是的"""

结果

>>> print(a)
你真帅
>>> print(b)
你真漂亮
>>> print(c)
你怎么
这么好看
>>> print(d)
是天生的吗
是的

推荐使用单引号来表示，因为双引号还得多按一个Shift键

字符串换行

您可能注意到了，在上面的例子中，在print出变量c与d时，显示是两行，那么能不能用一个单引号或双引号来做到换行效果呢

可以的，您只需要在字符串里加上 \n ，它表示一个换行符

>>> a = '你怎么\n这么好看' # 在字符串内加上\n表示换行

>>> a
'你怎么\n这么好看'

>>> print(a)
你怎么
这么好看

>>> b = '''你怎么
... 这么好看'''

>>> b # 下面的结果揭示了多行字符串只不过是当您回车时，解释器自动帮您添加上\n符号而已
'你怎么\n这么好看'

字符串基础操作

您可以通过索引来获取字符串中的某一个字符，亦可以用切片来获取字符串的某段子串

索引

在编程的世界中，一切都从0开始计数，比如字符串'abc'，那我们会说第0个字符是a、第1个字符才是b

如果这个让您困惑，不妨可以举如下例子，帮助理解

假如您家里电梯总共有三楼
按1楼按钮，电梯鸟都不鸟您，就不会移动，所以为0
按2楼按钮，它往上移动了1楼，所以为1
按3楼按钮，它往上移动了2楼，所以为2
所以这个计数其实是移动的步数

所以如果我们企图获取字符串中的某一个字符，指针也要作相应移动，我们使用字符串[移动步数]来获取某一个字符，比如字符串[0]获取第一个、字符串[1]获取第二个

>>> a = 'abc'

>>> a[0]
'a'

>>> a[1]
'b'

>>> a[2]
'c'

>>> a[3] # 注意如果您超过它的长度，将会报错，提示字符串的索引超出了范围
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

>>> length = len(a) # 我们可以用python内置函数len来查看字符串的长度，len是英文length的简写

>>> print(length) # 字符串a的最后一个字符的索引是2，所以这里如果我们的索引超过2，就会报错
3

切片

切片用于获取字符串中的某一部份，就像切三文鱼一样，我们用锋利的刀切出最好吃的部份; 我们使用字符串[开始步数:结束步数]来获取字符串中的某段

注意：切片的结果并不会包含结束步数处的元素

>>> a = 'abcd'

>>> a[0:1] # 第一个字符，相当于a[0]
'a'

>>> a[0:2] # 第一个字符至第二个字符
'ab'

>>> a[0:3] # 第一个字符至第三个字符
'abc'

字符串运算

与数字一样，字符串也有专属于它的运算 +、*、in

>>> a = '帅'
>>> b = '哥'
>>> c = 'abcd'

>>> a + b　# 字符串加法，表示将左右两个字符串顺序粘连在一起
'帅哥'

>>> a * 3 # 字符串加法，表示将目标字符串重复Ｎ次
'帅帅帅'

可以用in操作符，来查看字符串是否包含某段字符串，返回值是布尔值

>>> 'a' in c # 字符串'a'在字符串'abcd'里面吗
True

>>> 'bc' in c # 字符串'bc'在字符串'abcd'里面吗
True

>>> 'ac' in c # 字符串'ac'在字符串'abcd'里面吗
False

为什么最后一个是False！ac明明在'abcd'里面有啊？

因为必须要连续的，a位置是0，c位置是2，所以是非连续的，这里要特别注意

列表(List)

在python中，列表(list)是被使用的最频繁的一种数据类型，所以掌握它，很重要
您可以把列表想象成超市里的储物柜，其每一个格子都可以存任意的东西，甚至您可以往格子里再放一个储物柜，无线嵌套，就像盗梦空间一样
列表是可变的，就像格子可以先后放入不同客人的物品一样
我们以中括号 [、] 括住来表示一个储物柜，并以逗号 , 分隔其中每一个格子

例子

>>> a = [1,'背包','雨伞',3.14] # 创建了一个有4个元素的列表，我们在里面存了数字和字符串

>>> print(a) # 打印看看
[1, '背包', '雨伞', 3.14]

>>> a[1] # 支持索引，第二格存了什么
'背包'

>>> a[3] # 支持索引，第四格存了什么
3.14

>>> a[1:3] # 也支持切片，第二格到第二格存了什么
['背包', '雨伞']

列表的切片与字符串的切片有一丢丢的区别

>>> a = 'abc'
>>> b = ['a','b','c']
>>> a[0]
'a'
>>> a[0:1] # 这里注意到字符串的切片[0:1]与索引[0]是一样的效果，无论是索引还是切片得到的都是字符串
'a'
>>> b[0]
'a'
>>> b[0:1] # 但是列表的切片得到的永远是列表，索引就是得到其对应元素的类型
['a']

列表基础操作

>>> a = [1,2,3,4,5]

>>> print(a)
[1, 2, 3, 4, 5]

>>> a[2] = '中间' # 用字符串'中间'来替换列表的第三个元素

>>> print(a)
[1, 2, '中间', 4, 5]

>>> a[0:2] = ['第一','第二'] # 用切片来替换列表中第一、二个元素

>>> print(a)
['第一', '第二', '中间', 4, 5]

>>> a[0:2] = [1,2,3] # 如果切片赋值两边的长度不一致，左边的列表长度将会发生变化

>>> print(a) # 现在它的长度变为6
[1, 2, 3, '中间', 4, 5]

>>> a[0:2] = [] # 切片赋值给空列表，将导致原来的列表长度减2

>>> print(a)
[3, '中间', 4, 5]

列表也同样支持+、*、in操作符，但是它的in与字符串的in，有些许不同

>>> print(a)
[3, '中间', 4, 5]

>>> '中间' in a # 字符串'中间'在列表a里面吗
True

>>> 4 in a # 数字4在列表a里面吗
True

>>> [4, 5] in 列表[4, 5]在列表a里面吗
False

结果是False，区别就在这里了

对于字符串来说，in操作符可以检测单个或多个元素是否在其内，但是列表，只能检测单个元素是否在列表内

>>> b = [1,2]

>>> c = b + a # 列表同样支持加号+运算符，表示将左右两边列表按顺序粘连在一起

>>> print(c)
[1, 2, 3, '中间', 4, 5]

>>> b * 2 # 列表用样支持星号*运算符，表示将目标列表重复N次
[1, 2, 1, 2]

嵌套列表

上面说过，列表它里面可以存任意的类型，甚至列表里面可以再存个列表，那要怎样操作列表中的列表呢？

>>> a = [[1,2,3],[4,5,6],[7,8,9]] # 定义一个两层嵌套列表

>>> print(a) # 看看它长什么样
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> len(a) # 我们可以用python内置函数len，来查看列表的长度
3

居然是3，来看看这三个元素都长啥样

>>> a[0]
[1, 2, 3]

>>> a[1]
[4, 5, 6]

>>> a[2]
[7, 8, 9]

懂了，嵌套列表不就是一个列表里的元素也是一个列表嘛

如果我要获取9这个数字，要怎么做？

方法一:

>>> b = a[2]
>>> print(b[2])
9

方法二:

>>> print(a[2][2])
9

把上面两个步骤合并为一个，就不需要再创建一个变量b了

相当于左边a[2]先结合为一个整体，然后再和[2]结合在一起

元组(Tuple)

元组(tuple)和列表，它俩的关系就像孪生兄弟，长相和操作都很相似，但虽然是孪生兄弟，终归还是有些不一样，元组和列表的区别就是元组是不可变的(immutable)
如果非要拉元组做个比喻，元组也可以是个储物柜，但是只要您把东西存进去了，储物柜也不会把取物票给您，您只能通过透明玻璃看到格子里面有些啥，但是您永远不能再替换里面的东西了(哪有这么不合理的设计啊！)
我们以小括号 (、) 来表示一个元组，并以逗号 , 分隔其中每一个元素

例子

1. 元组同样支持列表的+、*和in操作符
2. 元组同样支持索引与切片操作
3. 只是元组是不可变的，列表是可变的

a = (1,2,3)
print(a) # (1, 2, 3)
print(a*2) # (1, 2, 3, 1, 2, 3)
print(a+a+a) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
print(2 in a) # True
print(4 in a) # False
print(a[0]) # 1
print(a[0:2]) # (1, 2)

但是如果您重新赋值元组的元素，将会报异常，比如

>>> a[0] = 'do it' # 报错，提示元组不支持元素赋值
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> a[0:2] = (100, 200) # 报错，提示元组不支持元素赋值
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组的两个天坑

情景1: 某天您定义了一个只有一个元素的元组

>>> a = (1) # 定义一个单元素的元组，貌似没毛病

>>> a[0] # 查看元组第一个元素，讲道理结果肯定是1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable

什么？ 报错是咋回事... 为啥提示整型不能进行索引操作？我的a明明是元组啊

>>> print(a) # 先看看变量a里是啥东西好了
1

1是什么鬼？ 我可爱的小括号呢？

>>> print(type(a)) # 通过内置函数type看看a的类型是啥
<class 'int'>

类型居然是整型，怪不得会报错

原来(1)被解释器认为是整数1了，傻逼解释器！！

那要怎样才能定义一个单元素元组呢？ 只需要在1后面再加一个逗号,

>>> a = (1,) # 在1后面多加个逗号试试
>>> print(a) # 好像没毛病哦
(1,)
>>> print(type(a)) # 看看类型，果然是tuple元组了!
<class 'tuple'>

但是列表却不会有这种问题

>>> b = [1]
>>> print(b)
[1]
>>> print(type(b))
<class 'list'>

难道元组不是python亲生的吗？ 为啥它哥没有这种问题，它却有？ 真是个弟弟！

其实学到后面的运算符的优先级时候，就知道为什么了，小括号也被python解释器认作最高优先级的运算符

例如我们计算1+1*2的时候，结果是3还是4呢？

从小学我们就知道，先乘除后加减，所以结果毫无疑问会是3

那么要怎么先计算1+1，然后再让它们的结果跟2相乘呢？

数学老师会教您先用小括号()括住1+1就行了，(1+1)*2这样结果就是4了

>>> 1+1*2
3
>>> (1+1)*2
4

所以当您写出(1+1)这样的表达式的时候，别说python解释器了，我们人都不知道()到底在表示元组还是运算符，所以单个元素时必须要多加个逗号,来告诉解释器，这是一个元组

>>> (1+1)
2
>>> (1+1,)
(2,)

情景2: 某天您在定义赋值一个变量时，不小心在结尾多加了一个逗号,

>>> a = 1, # 本意是定义一个整数1，结果不小心在结尾多加了个逗号
>>> b = 2
>>> a + b # 当您信心满满，认为结果肯定是3的时候
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "int") to tuple

报错了，提示元组只能与元组相加...

为啥又报错了，傻逼解释器吧，我这哪来的元组？ 还能愉快的玩耍吗？

>>> print(a) # 看看a是啥
(1,)
>>> type(a) # 看了看a的类型，居然是元组！
<class 'tuple'>

原来没有小括号()括住，用逗号,分隔的几个元素，也会被python视作元组!

>>> a = '原','来','如','此'
>>> a
('原', '来', '如', '此')
>>> print(type(a))
<class 'tuple'>

尽管如此，您必须始终坚持以小括号()括住、以逗号,分隔的语法来定义一个元组，因为这样更加明确

字典(Dictionary)

字典(dictionary)，同样是python中被使用频率最高的一种数据类型，说到字典，您可能会联想到新华字典、英汉字典，没错，它们确实很相似
字典有两个重要的概念，分别是键(key)与值(value)，一个键对应一个值，就像一本书的页码对应其中某一页内容
字典可以说是一种映射类型，它用花括号 {} 来表示，里面每一项键值对用 key:value 表示，并以逗号 , 分隔其中每一个键值对

例子

新建

# 创建一个字典a
# 其中字符串'a'为键，对应着值整数1
# 字符串'b'为另一个键，对应着值整数2
a = {'a': 1, 'b': 2}
print(a) # {'a': 1, 'b': 2}

# 或者可以这样达到同样的目的
b = {} # 创建一个空字典
b['a'] = 1 # 将字符串'a'作为字典b新的键，对应着值整数1
b['b'] = 2 # 将字符串'b'作为字典b新的键，对应着值整数2
print(b) # {'a': 1, 'b': 2}

删除(delete)

a = {'a': 1, 'b': 2}

# 您可以用del(delete的简写)标识符来删除字典的一个键
del a['a'] # 删除键'a'

print(a) # {'b': 2}

修改

a = {'a': 1, 'b': 2}
a['a'] = 'hello' # 将键'a'指向了新的值字符串'hello'
print(a) # {'a': 'hello', 'b': 2}

查看

a = {'a': 1, 'b': 2}
print(a['a']) # 查看键'a'对应的值，为1
print(a['b']) # 查看键'b'对应的值，为2

# 您可以通过.号来调用字典的方法(函数)，如果您暂时不理解，先记住
# 查看字典a的所有键，可以调用字典的方法keys
print(a.keys()) # dict_keys(['a', 'b'])

# 查看字典a的所有值，可以调用字典的方法values
print(a.values()) # dict_values([1, 2])

# 查看字典a的所有键值对，可以调用字典的方法items
print(a.items()) # dict_items([('a', 1), ('b', 2)])

不单单可以将字符串作为字典的键，实际上您可以将所有不可变的类型作为字典的键

# 在这个例子中，我们先以字符串作为键、再以数字作为键，最后以元组作为键
# 在本文后面的篇章，您会知道字符串、数字和元组都是不可变的数据类型
a = {'1': 'a', 2: 'b', (3,): 'c'}
print(a) # {'1': 'a', 2: 'b', (3,): 'c'}

print(a['1']) # 'a'
print(a[2]) # 'b'
print(a[(3,)] # 'c'

字典的键是唯一(同样的键只能出现一次)的，值可以重复

# 检验键的唯一性，我们先后定义了键'a'，并把它们对应了不同的值
a = {'a':1, 'a':2}
print(a) # {'a': 2}
# 可以看到字典只保留了最后一个键值对'a':2
# 就像书一样，它不可能出现两个页码相同的书页

# 检验值的可重复
b = {'a':1, 'b':1}
print(b) # {'a':1, 'b':1}
# 没问题，在字典中，值是可以相同的
# 就像书的不同目录可以指向同一页书一样

字典不支持+、*号操作符，但支持in，不同的是in是用来检测某个值是否存在于字典的键中，而不是值

a = {'a':1, 'a':2}

# 字符串'a'在字典a的键中吗
'a' in a # True

# 字符串'c'在字典a的键中吗
'c' in a # False

仰望未来，听说在python3.9版本中，字典的合并支持以竖线|操作符来实现

或利用|=进行原地更新，效果与字典的update方法有点类似

# | 操作符会构建一个新的字典
a = {'a':1}
b = {'b':2}
c = a | b
print(c) # {'a': 1, 'b': 2}

# |= 操作符会原地更新至a
a|=b
print(a) # {'a': 1, 'b': 2}

如果在python3.9以前的版本，比如python3.8.3，一般这样来达到同样目的

# 以下效果相当于py39中的|
a = {}
b = {'a':1}
c = {'b':2}
a.update(b)
a.update(c)
print(a) # {'a': 1, 'b': 2}

# 以下效果相当于py39中的|=
b.update(c)
print(b) # {'a': 1, 'b': 2}

如果您看不懂上述py39的新特性，无需理会，因为暂时并不重要，我们专注于py3.8.3就可以了

集合(Set)

python的集合(set)与数学概念上的集合同样具有三个特性，确定性、互异性、无序性
在python中，集合一般用于删除重复元素或进行成员关系测试
集合的表示，与字典有点相似，都是用花括号 {} 括住，然后逗号 , 分隔其中每一个成员

集合的创建与特性

a = {1,2,3} # 创建一个长度为3的集合
print(a) # {1,2,3}

# 集合的确定性: 一个元素要么属于一个集合，要么不属于，只有这两种情况
# 利用in操作符来查看一个元素是否属于该集合
print(1 in a) # True
print(4 in a) # False

# 集合的互异性: 一个集合内的元素必定不会重复
b = {1,1,1,2,2,3,3} # 创建时包含重复元素
# 可以看到多余的1、2、3已被去除
print(b) # {1, 2, 3}

# 集合的无序性: 元素之间是无序的
c = {3, 1, 2}
# 顺序已发生变化
print(c) # {1, 2, 3}
# 看看集合a与集合c是否相等，==是相等比较符，它用于比较左右两边是否相等，返回True或False
print(a == c) # True

有一种集合叫空集，您不能以{}来定义空集，因为{}会被python解释器认为是空字典，只能用内置函数set来定义空集

a = set() # 创建一个空集合
print(a) # 输出: set()，以表示其为一个空集

# 可以把字符串、列表、元组等可迭代类型传递给内置函数set，来创建一个集合
b = [1,2,3]
c = set(a)
print(c) # {1, 2, 3}

d = set('hello,world')
print(d) # {'w', 'e', 'o', ',', 'h', 'r', 'l', 'd'}

集合的基本操作

增加元素

a = {1, 2}

# 利用集合的add方法，增加一个元素
a.add(3)
print(a) # {1, 2, 3}

# 利用集合的update方法，增加多个元素
# update方法接受一个可迭代类型
a.update([4,5])
print(a) # {1, 2, 3, 4, 5}

删除元素

a = {1, 2, 3}

# 利用集合remove方法，删除值等于所给值的元素
a.remove(3)
print(a) # {1, 2}

# 利用集合的pop方法，随机删除其中一个元素
a.pop()
print(a) # {2}

# 利用集合的clear方法，来让其变为空集
a.clear()
print(a) # set()

集合的基本运算

集合不支持+与*号操作符，但是它有它自己独有的运算

a = {1,2,3}
b = {3,4,5}

# 交集: 你有我也有
# 求交集用&符号
print(a & b) # {3}

# 并集: 我有的加上你有的
# 求并集用|符号
print(a | b) # {1, 2, 3, 4, 5}

# 差集: 我有你没有
# 求差集用-减号
print(a - b) # {1, 2}

# 异或集：去掉大家都有的，然后再加起来
# 求异或用^符号
print(a ^ b) # {1, 2, 4, 5}

# 子集: 我有的，你全都有，那我就是你的子集，你就是我的超集
# 判断一个集合是否为另一个集合的子集，用大于等于>=或小于等于<=符号
print({1,2} <= {1,2,3}) # True
print({1,2,3} >= {1,2,3}) # True

# 真子集: 我有的，你全都有，而且还有我没有的，那我就是你的真子集，你就是我的真超集
# 判断一个集合是否为另一个集合的真子集，用大于>或小于<符号
print({1,2,3} < {1,2,3}) # False
print({1,2} < {1,2,3}) # True

可变与不可变类型

在以上6种基本数据类型，如果以是否可变来分类，可以分为两类

可变类型(mutable)

它元素的值是可以改变的，也叫做引用类型

• 列表(list)
• 字典(dictionary)
• 集合(set)

不可变类型(immutable)

元素是不可改变的，要改变只能重新赋值来覆盖，也叫做值类型

• 数字(number)
• 字符串(string)
• 元组(tuple)

我们可以用python内置函数id来获取目标对象存放在内存中的地址

# 可变
a = [1, 2]
b = {'a':1}
c = {1, 2}

# 不可变
d = 3.14
e = 'hello'
f = (1, 2)

# 利用id来获取目标在内存中的地址
# 注意不同的运行环境，会有不同的结果，但是效果一样
print(id(a)) # 140042188515456

# 改变a内元素的值
a[0] = 100
print(a) # [100, 2]

# 再次查看其内存地址，如果没有变化，证明还是同一个数据，但是它的内容却变化了，所以说是可变类型
print(id(a)) # 140042188515456

# 看看字符串的id
print(id(e)) # 140042188516848

# 尝试改变字符串内的某个字符
# >>> e[0]='f'
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'str' object does not support item assignment
# 会报错，提示字符串不能被改变

# 重新赋值变量e另外一个字符串
e = 'i see'
# 看看id，已经发生变化，所以不再是同一个数据了，所以叫不可变类型
print(id(e)) # 140042188516272

再论变量

如果您之前学过别的编程语言，比如C或C++，您会发现，在python中，不需要事先声明变量，只需要在使用前给变量赋值即可，所以我们把python称作弱类型语言，而把C或C++等称作强类型语言
变量并不等于以上各种基本数据类型，如果您把一个数据类型赋值给一个变量，变量所做的工作只是帮您找到那个类型而已，如果把数据类型比作一栋建筑，那么变量只是指向它的路标
用一个等号=来给变量赋值，它的左边是变量的命名，右边是变量指向的类型，要注意两个等号==是比较运算符

可以用多个变量指向同一个数据

# 变量a指向字符串
a = '我是一个字符串'
# 也令变量b指向同一个字符串
b = a
# 现在有两个变量指向同一个字符串了

# 相等比较运算符，它的作用是比较变量指向的值是否相等
print(a == b) # True

与==不同，它是比较值是否相等，如果要查看是否同一个数据，可以用is操作符

事实上，is操作符是比较两者内置函数id的结果是否相等

a = 'abc'
b = 'abc'
c = a

# 值都相等
print(a == b) # True
print(a == c) # True

# 但a与b并不是同一个数据
print(a is b) # False
# a与c是同一个数据
print(a is c) # True

# 又比如
d = [1,2]
e = [1,2]
f = d

# 变量d与f是指向同一个数据，且它们指向的是引用类型(可变类型)
# 如果改变d
d[0] = 100
print(d) # [100, 2]
# f会发生变化，因为它们指向的是同一个数据
print(f) # [100, 2]

# 改变e
e[0] = 200
print(e) # [200, 2]
# d还是原样
print(d) # [100, 2]

# 因为一开始赋值时，d与e的值虽然相等，但它们并不是同一个数据
print(d is e) # False
print(id(d) == id(e)) # False

如果把一个数据类型比作一栋建筑，变量比作找到它的方式，假如现在有两个变量指向那栋建筑，其中一个变量是高德地图，另外一个变量是祖传指南针，通过它们俩，我们都能找到那栋建筑

如果出了啥意外，两个变量都找不到那栋建筑了，会怎样？

我们一开始只有两种方法找到那栋建筑，通过高德地图或祖传指南针，现在它们都失灵了，那我们人类也就再也找不到那栋建筑了，久而久之，那栋建筑就会因为风化、年久失修而被摧毁，就没了...没了...

我们可以通过del来删除一个变量

# 1是那栋建筑
a = 1
b = a

# 现在有两种方式找到它
# 通过a
print(a) # 1
# 或是通过b
print(b) # 1

# 把变量a给弄没
del a
# print(a) 将会报错，提示没有该变量

# 现在还能通过b来找到那栋建筑1
print(b) # 1

# 把变量b也给弄没
del b

# 好了，再也找不到建筑1了
# 它迟早会被风化毁掉!!

多个变量赋值

您可以通过两种方式给多个变量赋值

# 可以同时为多个变量赋给同一值
a = b = c = 1
# print函数用逗号分隔多个，可以同时打印输出多个值
print(a, b, c) # 1 1 1
print(a is b) # True
print(a is c) # True
print(b is c) # True

# 可以同时为多个变量赋给不同值
d, e, f = 1, 2, 3
print(d, e, f) # 1 2 3

变量的命名法

变量的命名法也可以叫做变量的命名规范，它与变量的命名规则不一样，规则就像法律，你必须遵守，但规范就像道德，只是建议最好这样做

经典命名法一览

# 驼峰命名法：首字母小写，其余首字母大写
handsomeMan = 'you'

# 帕斯卡命名法：首字母皆为大写
HandsomeMan = 'you'

# 匈牙利命名法
# 匈牙利命名法是早期的规范，由微软的一个匈牙利人发明的，是 IDE 还十分智障的年代的产物。那个年代，当代码量很多的时候，想要确定一个变量的类# 型是很麻烦的，不像现在 IDE 都会给提示，所以才产生了这样一个命名规范，估计现在已经没啥人用了吧……一个十分系统却又琐碎的命名规范。
# 该命名规范，要求前缀字母用变量类型的缩写，其余部分用变量的英文或英文的缩写，单词第一个字母大写。
iMyAge = 18 # "i": int
fMyHeight = 180  # "f": float

# 蛇型命名法：以下划线_连接单词
handsome_man = 'you'

python推荐蛇型命名法，因为python的中文名叫蟒蛇，它的图标就是一条蛇

学到后面，您会发现，python很多魔法属性都有下划线的踪影

总结

1. 初步掌握python的6种基本类型
2. 了解变量的本质
3. 了解各种变量命名规范