java怎么放mysql的text类型数值让其换行_Python零基础入门-数据类型与变量

数据类型与变量

大纲

• 前言
• 基本数据类型
  • 数字(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)) #  int是integer的简写print(type(b)) # print(type(c)) #  bool是boolean的简写print(type(d)) # 

常用数值运算

>>> 1 + 1 # 加法2>>> 3 - 1.5 # 减法1.5>>> 2 * 5 # 乘法10>>> 10 / 3 # 除法, 注意无论是否能整除，得到的都是一个浮点数3.3333333333333335>>> 10 / 52.0>>> 10 // 5 # 两个斜杠来表示整除，这样会得到一个整数2>>> 10 % 3 # 百分号表示取余运算1>>> 2 ** 3 # 两个星号表示乘方运算，这里表示2的3次方8

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

>>> 1 + 1.02.0

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

不信来试试

>>> 1 + True2>>> True + True # 1 + 1 = 22>>> False == 0 # False等于数值0True>>> type(True) # True是bool类的一个实例>>> issubclass(bool, int) # bool类是int类的子类，内置方法issubclass用于查看一个类是否为另一个类的子类True>>> bool.__base__ # bool类是int类的子类，__base__是魔法属性，其指向父类>>> 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时，显示是两行，那么能不能用一个单引号或双引号来做到换行效果呢

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

>>> a = '你怎么这么好看' # 在字符串内加上表示换行>>> a'你怎么这么好看'>>> print(a)你怎么这么好看>>> b = '''你怎么... 这么好看'''>>> b # 下面的结果揭示了多行字符串只不过是当您回车时，解释器自动帮您添加上符号而已'你怎么这么好看'

字符串基础操作

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

索引

在编程的世界中，一切都从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 "", line 1, in 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) # Trueprint(4 in a) # Falseprint(a[0]) # 1print(a[0:2]) # (1, 2)

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

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

元组的两个天坑

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

>>> a = (1) # 定义一个单元素的元组，貌似没毛病>>> a[0] # 查看元组第一个元素，讲道理结果肯定是1Traceback (most recent call last):  File "", line 1, in TypeError: 'int' object is not subscriptable

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

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

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

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

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

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

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

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

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

>>> b = [1]>>> print(b)[1]>>> print(type(b))

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

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

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

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

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

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

>>> 1+1*23>>> (1+1)*24

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

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

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

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

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

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

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

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

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

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

字典(Dictionary)

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

例子

新建

# 创建一个字典a# 其中字符串'a'为键，对应着值整数1# 字符串'b'为另一个键，对应着值整数2a = {'a': 1, 'b': 2}print(a) # {'a': 1, 'b': 2}# 或者可以这样达到同样的目的b = {} # 创建一个空字典b['a'] = 1 # 将字符串'a'作为字典b新的键，对应着值整数1b['b'] = 2 # 将字符串'b'作为字典b新的键，对应着值整数2print(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'对应的值，为1print(a['b']) # 查看键'b'对应的值，为2# 您可以通过.号来调用字典的方法(函数)，如果您暂时不理解，先记住# 查看字典a的所有键，可以调用字典的方法keysprint(a.keys()) # dict_keys(['a', 'b'])# 查看字典a的所有值，可以调用字典的方法valuesprint(a.values()) # dict_values([1, 2])# 查看字典a的所有键值对，可以调用字典的方法itemsprint(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 | bprint(c) # {'a': 1, 'b': 2}# |= 操作符会原地更新至aa|=bprint(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) # Trueprint(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或Falseprint(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}) # Trueprint({1,2,3} >= {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.14e = 'hello'f = (1, 2)# 利用id来获取目标在内存中的地址# 注意不同的运行环境，会有不同的结果，但是效果一样print(id(a)) # 140042188515456# 改变a内元素的值a[0] = 100print(a) # [100, 2]# 再次查看其内存地址，如果没有变化，证明还是同一个数据，但是它的内容却变化了，所以说是可变类型print(id(a)) # 140042188515456# 看看字符串的idprint(id(e)) # 140042188516848# 尝试改变字符串内的某个字符# >>> e[0]='f'# Traceback (most recent call last):#   File "", line 1, in # 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) # Trueprint(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是指向同一个数据，且它们指向的是引用类型(可变类型)# 如果改变dd[0] = 100print(d) # [100, 2]# f会发生变化，因为它们指向的是同一个数据print(f) # [100, 2]# 改变ee[0] = 200print(e) # [200, 2]# d还是原样print(d) # [100, 2]# 因为一开始赋值时，d与e的值虽然相等，但它们并不是同一个数据print(d is e) # Falseprint(id(d) == id(e)) # False

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

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

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

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

# 1是那栋建筑a = 1b = a# 现在有两种方式找到它# 通过aprint(a) # 1# 或是通过bprint(b) # 1# 把变量a给弄没del a# print(a) 将会报错，提示没有该变量# 现在还能通过b来找到那栋建筑1print(b) # 1# 把变量b也给弄没del b# 好了，再也找不到建筑1了# 它迟早会被风化毁掉!!

多个变量赋值

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

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

变量的命名法

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

经典命名法一览

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

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

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

总结

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