Python基础之变量

Posted 2021-06-25 天马行空

扎扎实实地打好基础，练好基本功，我认为这是学好Python的“秘诀”。老子曾云：九层之台，起于垒土。本文主要以一些简单的小例子简述Python基础之变量相关内容，仅供学习分享使用，如有不足之处，还请指正。

什么是变量？

变量是指在程序执行过程中，值可以发生变化的量。与之对应的是常量，常量是指在程序执行过程中，值不可以发生变化的量。变量和常量都是为了获取和设置内存中对应地址的值，而便于记忆和识别而起的名称。

Python中常用变量类型

Python中常用的变量类型，主要包括：Number(数字)，String(字符串)，List(列表)，Tuple(元组)，Dictionary(字典)，如下图所示：

 变量的命名规则

Python中，变量的命名规则如下：

1. 变量名不能用数字开头
2. 变量名不能包含特殊的符号
3. 变量名应该有意义，避免使用a,b,c来命名变量
4. 如果必须在一个变量名中用多个单词，请用下划线来分隔
5. 大多数情况下，变量名应该小写
6. 如果使用单个字母命名，避免使用小写L或者大写O

错误或不友好的变量命名

错误或不友好的变量命名，示例如下所示：

>>> 1name=\'Alan.hsiang\'
SyntaxError: invalid syntax
>>> a=1
>>> b=2
>>> b*c=3
SyntaxError: can\'t assign to operator
>>> b$c=2
SyntaxError: invalid syntax
>>> 

友好的变量命名

友好的变量命名示例，如下所示：

>>> name=\'Alan.hsiang\'
>>> name_age="Alan.hsiang \'s age is 20"
>>> age =20

 Number类型（数字）

在Python3中，支持的数字类型，共有以下几种：

int 整型，包括正整数，负整数，0，可以通过二进制，八进制，十进制，十六进制，进行表示。

int类型示例如下所示：

>>> num1=2   #十进制
>>> num1
2
>>> num2=0b101  #二进制
>>> num2
5
>>> num8=0o24  #八进制
>>> num8
20
>>> num16=0x3F  #十六进制
>>> num16
63
>>> 

float 浮点型，包含两部分：整数部分，小数部分。通过整数.小数来表示，也可以通过科学计数法表示。

float类型示例如下所示：

>>> float_num1=2.345 # 普通表示法
>>> float_num1
2.345
>>> float_num2 =1.23e9 #科学计数法
>>> float_num2
1230000000.0
>>> 

bool 布尔类型，表示逻辑值，值只有两个：True,False。

bool类型示例如下所示：

>>> b_var1=True  # 注意大小写敏感
>>> b_var1
True
>>> b_var2=False  # 注意大小写敏感
>>> b_var2
False
>>> 

注意：True和False是关键字，大小写敏感，不能写错，错误示例如下：

>>> b_var3=true
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    b_var3=true
NameError: name \'true\' is not defined
>>> b_var4=false
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    b_var4=false
NameError: name \'false\' is not defined
>>> 

complex 复数类型，以3+4j格式表示。

complex示例如下所示：

>>> c_num=complex(3,4)
>>> c_num
(3+4j)
>>> 

type方法的使用

type方法主要用于判断当前变量的数据类型，如下所示：

>>> type(num1)
<class \'int\'>
>>> type(float_num1)
<class \'float\'>
>>> type(b_var1)
<class \'bool\'>
>>> type(c_num)
<class \'complex\'>
>>> 

Python数学运算符

Python支持的常规数学运算符，如下所示：

 常规数学运算符，示例如下：

>>> a=5
>>> b=2
>>> a+b
7
>>> a*b
10
>>> a**b
25
>>> a/b
2.5
>>> a//b
2
>>> a%b
1
>>> 

 Python比较运算符

Python支持的比较运算符，如下所示：

 比较运算符，示例如下：

>>> a=20
>>> b=10
>>> a==b
False
>>> a!=b
True
>>> a>b
True
>>> a<b
False
>>> a>=b
True
>>> a<=b
False
>>> 

Python赋值运算符

Python支持的赋值运算符，如下所示：

 赋值运算符，示例如下：

>>> c=a+b
>>> c
30
>>> c+=a
>>> c
50
>>> c-=a
>>> c
30
>>> c*=a
>>> c
600
>>> c/=a
>>> c
30.0
>>> c%=a
>>> c
10.0
>>> c**=a
>>> c
1e+20
>>> c//=a
>>> c
5e+18
>>> 

Python逻辑运算符

Python支持的逻辑运算符，如下所示：

 逻辑运算符，示例如下：

>>> a and b # 如果a为True , 则返回 b 计算的值
10
>>> a or b # 如果a 为True，则返回a 的值，否则，返回b的值
20
>>> not a # 如果a 为 True，则返回 False
False
>>> 

Python成员运算符

Python支持的成员运算符，用于测试成员是否包含在序列中，包括字符串，列表，元组等，如下所示：

 成员运算符，示例如下：

>>> list=[4,5,6,7,8,9,0]
>>> 5 in list
True
>>> 3 in list
False
>>> 3 not in list
True
>>> 5 not in list
False
>>> 

Python身份运算符

身份运算符，用于比较两个对象的存储单元，如下所示：

 身份运算符，示例如下所示：

>>> a=b
>>> a is b
True
>>> a is not b
False
>>> b=3
>>> a is b
False
>>> a is not b
True
>>> 

String类型（字符串）

字符串类型是最常用的数据类型之一。可以用引号（单引号或 双引号）来创建字符串。字符串中的字符，可以包含，字符，字母，中文字符，特殊符号等内容。

创建字符串

Python创建字符串非常简单，只需要为变量分配一个字符串类型的值即可。示例如下：

>>> str1 = \'apple\'
>>> str1
\'apple\'
>>> str2 = "apple"
>>> str2
\'apple\'
>>> str3 = "apple\'color is red"
>>> str3
"apple\'color is red"
>>> str4 = \'apple is very "good"\'
>>> str4
\'apple is very "good"\'
>>> 

注意：Python中，支持英文单引号和双引号两种方式定义字符串，主要是为了避免字符串内容中包含引号的情况。

字符串错误示例，如下所示：

>>> str5= \'apple\'is good\'
SyntaxError: EOL while scanning string literal
>>> str6 = \'apple\' hahaha\'
SyntaxError: invalid syntax
>>> str7 = ‘abc’
SyntaxError: invalid character in identifier
>>> 

多行字符串

如果字符串有多行，需要用三个单引号或双引号来定义。如下所示：

>>> str8 = \'\'\'大家好
我是Alan.hsiang
我是一个man
我很懒\'\'\'
>>> print(str8)
大家好
我是Alan.hsiang
我是一个man
我很懒
>>> str8
\'大家好\\n我是Alan.hsiang\\n我是一个man\\n我很懒\'
>>> 

访问字符串

在Python中，可以通过序号来访问字符串中的某一个或多个字符，序号从0开始。

>>> str4 = \'apple is very "good"\'
>>> str4[0]  # 正向访问
\'a\'
>>> str4[2]
\'p\'
>>> str4[-1]  # 反向访问
\'"\'
>>> str4[-2]
\'d\'
>>> str4[1:2] #切片访问，从1开始，2结束，不包含2
\'p\'
>>> 

更新字符串

字符串的内容是只读的，不允许更新。如果非要更新，可以转换成列表，修改后，再转换成字符串，这种折中方法。如下所示：

>>> list1=list(str1)
>>> list1
[\'a\', \'p\', \'p\', \'l\', \'e\']
>>> list1[0]=\'A\'
>>> list1
[\'A\', \'p\', \'p\', \'l\', \'e\']
>>> str1 = "".join(list1)
>>> str1
\'Apple\'
>>> 

在转换时，如果报以下错误，是由于之前声明list为变量，所以访问不到内置函数。所以也请注意：变量命名要规范，不能使用关键字。

>>> list2 = list(str1)
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    list2 = list(str1)
TypeError: \'list\' object is not callable

List类型（列表）

什么是列表？

列表是Python中非常重要的一种数据结构，由一系列按特定顺序排列的元素组成，开发者可以创建包含字母，数字的列表，也可以将任何元素加入列表中，元素之间的数据类型可以不同。列表中的每一个元素，都被分配了一个索引，代表元素在列表中的位置。索引从0开始。在Python程序中，用英文中括弧表示列表，并用逗号分隔列表的元素。

如何创建列表？

列表的创建也非常简单，通过变量 = [元素1,元素2,...,元素n]的格式来创建，如下所示：

>>> fruits = [\'apple\',\'pear\',\'banana\']
>>> print(fruits)
[\'apple\', \'pear\', \'banana\']
>>> type(fruits)
<class \'list\'>
>>> list2 = []
>>> list3 = [1,2,3,\'a\',\'b\',4,5]
>>> print(list3)
[1, 2, 3, \'a\', \'b\', 4, 5]
>>> 

如何访问列表？

列表是通过索引进行访问的，可以通过 列表名称[索引] 的格式进行访问。如下所示：

>>> fruits[1]
\'pear\'
>>> list3[3]
\'a\'
>>> 

注意：列表的索引从0开始。

如果要访问的列表的内容，超出了列表的范文，则会报以下错误：

>>> list3[7]
Traceback (most recent call last):
  File "<pyshell#89>", line 1, in <module>
    list3[7]
IndexError: list index out of range

Python的列表，不仅支持正向索引，还支持负向索引，如下所示：

>>> list3[-1]
5
>>> list3[-2]
4
>>> 

同样，列表也支持切片的方式进行访问，如下所示：

>>> list3[1:4] # 起始位置，结束位置，包含起始，不包含结束
[2, 3, \'a\']
>>> 

 Tuple类型（元组）

在Python程序中，可以将元组看做是特殊的列表，与列表不同的是，元组内的元素不能发生改变。不但不能改变元组内的数据项，也不能添加和删除数据项。当需要创建一组不可改变的数据时，通常会把这些数据放在元组中。

如何创建并访问元组？

在Python程序中，元组是以小括号将数据括起来，各个元素之间用逗号隔开。也可以创建空元组。具体如下所示：

>>> t1 = (\'a\',\'b\',\'c\')
>>> t1
(\'a\', \'b\', \'c\')
>>> type(t1)
<class \'tuple\'>
>>> t1[1]
\'b\'
>>> t1[1]=\'B\' # 如果尝试修改元组的元素内容，则会报错
Traceback (most recent call last):
  File "<pyshell#98>", line 1, in <module>
    t1[1]=\'B\' # 如果尝试修改元组的元素内容，则会报错
TypeError: \'tuple\' object does not support item assignment
>>> 

当元组中只有一个元素时，需要在元组后面添加逗号，如下所示：

>>> t2 = (2) # 如果只有一个元素，不加逗号，则不是元组
>>> type(t2)
<class \'int\'>
>>> t3= (2,) # 如果只有一个元素，加上逗号，就表示元组
>>> type(t3)
<class \'tuple\'>
>>> 

元组同列表一样，支持索引和切片访问，如下所示：

>>> t1[1]
\'b\'
>>> t1[1:3]
(\'b\', \'c\')
>>> 

使用内置方法操作元组

元组常用的内置方法，如下所示：

1. len() 获取元组的长度，即元素个数。
2. max() 获取元组中元素的最大值。
3. min() 获取元组中元素的最小值。

元组使用内置函数，如下所示：

>>> t1 = (\'a\',\'b\',\'c\')
>>> t1
(\'a\', \'b\', \'c\')
>>> len(t1)
3
>>> max(t1)
\'c\'
>>> min(t1)
\'a\'
>>> 

 Dictionary类型（字典）

什么是字典？

字典，是以大括号{}包围，并且以“键:值”对的方式声明和存在的数据集合。字典与列表相对，最大的不同在于字典是无序的，其成员位置只是象征性的，在字典中，通过键来访问成员，而不能通过其位置来访问成员。

创建并访问字典

字典中可以存储任意个键-值对。每一个键-值对中的键（Key）必须是唯一的，不可变的，但值（Value）则不必。键值可以取任意数据类型。格式如下：dict1={key1:value1,key2:value2}

创建并操作字典示例如下所示：

>>> dict1={\'a\':1,\'b\':2}
>>> dict2={} # 空字典
>>> type(dict1)
<class \'dict\'>
>>> dict2[\'apple\']=\'big\' # 添加元素
>>> dict2[\'orange\']=\'small\' # 添加元素
>>> dict2
{\'apple\': \'big\', \'orange\': \'small\'}
>>> dict1[\'a\'] =-1 # 修改元素的值
>>> dict1
{\'a\': -1, \'b\': 2}
>>> del dict1[\'a\'] # 删除键值
>>> dict1
{\'b\': 2}
>>> 

与字典相关的内置函数

与字典相关的内置函数，如下所示：

1. len()  求字典的元素的个数
2. str() 将字典转换成字符串。

内置函数，示例如下：

>>> len(dict2)
2
>>> str(dict2)
"{\'apple\': \'big\', \'orange\': \'small\'}"
>>> 

备注

合抱之木,生于毫末。——老子《老子》