Python 变量、数据类型、运算符

1. 变量与数据类型

1.1 什么是变量

1.2 Python中的命名规范

1.3 数据类型

1.4 可变类型与不可变类型

2. Python中的“引用”概念

3. 常用的数据类型转换

4. 运算符

4.1 算数运算符

4.2 赋值运算符

4.3 位运算符

4.4 比较（关系）运算符

4.5 逻辑运算符

 

 

1. 变量与数据类型

1.1 什么是变量

在Python中，存储一个数据，需要一个叫做变量的东西。

程序就是用来处理数据的，而变量就是用来存储数据的。

num1 = 100  # num1就是一个变量，好比一个菜篮子

num2 = 87  # num2也是一个变量

result = num1 + num2  # 把num1和num2这两个"菜篮子"中的数据进行累加，然后放到result变量中

 

1.2 Python中的命名规范

什么是标识符？

• 标识符是开发人员在程序中自定义的一些符号和名称，如变量名 、函数名等。
• 标示符由字母、下划线和数字组成，且数字不能开头。

命名规范

1. 小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog

2. 大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName

3. 在程序员中还有一种命名法比较流行，就是用下划线“_”来连接所有的单词，比如send_buf

关键字

• 关键字，是Python已经使用的了,一些具有特殊功能的标示符，所以不允许开发者自己定义和关键字相同的名字。
• 查看Python中关键字的方法：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

• 在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性。

>>> # 单行注释
>>> """
... 多行注释
... ……
... """

 

1.3 数据类型

在Python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要开发者主动地声明它的类型，系统就会自动识别。

想一想，我们应该让变量占用多大的空间，保存什么样的数据？

在程序中，为了更充分地利用内存空间以及更有效率地管理内存，数据是有不同的类型的，如下所示：

1. Number（数字）
   1. int（有符号整型）
   2. long（python2有，而3没有）
   3. float（浮点型）
   4. complex（复数）
   5. bool（布尔）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Dictionary（字典）
6. Set（集合）

 

bool（布尔）：

• 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True；
• 在 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

>>> True + 2
3
>>> False / 2
0.0

 

可以使用 type() 函数来查看变量的类型：

>>> a = 1
>>> type(a)
<class 'int'>
>>> b = 1.0
>>> type(b)
<class 'float'>
>>> c = 1+1j
>>> type(c)
<class 'complex'>
>>> d = True
>>> type(True)
<class 'bool'>
>>> e = [1, 2, b]
>>> type(e)
<class 'list'>
>>> f = (1, 2, b)
>>> type(f)
<class 'tuple'>
>>> g = {1: a, "b": 2}
>>> type(g)
<class 'dict'>
>>> h = {1, a, 2}
>>> type(h)
<class 'set'>

还可以使用 isinstance() 函数来判断：

>>> a = 1
>>> isinstance(a, int)
True

type() 与 isinstance() 的区别：

• type()：认为子类与父类不是同一类型。

• isinstance()：认为子类与父类是同一类型。

>>> class A:
...     pass
...
>>> class B(A):
...     pass
...
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

 

1.4 可变类型与不可变类型

不可变类型，即其值不可改变（当变量的值发生改变时，其引用的内存地址也发生改变）：

• 数值
• 字符串
• 元组

可变类型，即其值可以改变（当变量的值发生改变时，其引用的内存地址不发生改变）：

• 列表
• 字典
• 集合

>>> a = 1
>>> id(a)
1349380016
>>> a = 2  # 此时已改变了引用的内存地址
>>> id(a)
1349380032
>>>
>>> a = "a"
>>> id(a)
15288384
>>> a = "b"  # 此时已改变了引用的内存地址
>>> id(a)
15320000
>>>
>>> a = [1, 2]
>>> id(a)
51719336
>>> a[0] = 2  # 此时是在原有内存地址上进行修改
>>> a
[2, 2]
>>> id(a)
51719336

 

2. Python中的“引用”概念

在 python 中，值是靠引用来传递的，如下图所示：

• 在C语言中，变量a和变量b均各自保存着100的值；
• 而在python中，变量a和变量b引用的是同一份（即100这个值的）内存地址。

 

可以用 id() 函数来判断两个变量是否为同一个值的引用，可以将 id 值理解为那块内存地址标示。

示例1：不可变类型的引用

 1 >>> a = 1
 2 >>> b = 1
 3 >>> id(a)
 4 1349380016
 5 >>> id(b)  
 6 1349380016  # 两个变量的id值相同
 7 >>> a = 2
 8 >>> id(a)  
 9 1349380032  # 变量a的id值已改变
10 >>> id(b)  
11 1349380016  # 变量b的id值未变

示例2：可变类型的引用

>>> a = [1, 2]
>>> b = a
>>> id(a)
51719368
>>> id(b)
51719368
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
51719368
>>> id(b)
51719368  # 变量a和变量b的id值始终一致

 

3. 常用的数据类型转换

函数	说明
int(x)	将x转换为一个整数
long(x)	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real)	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式，并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(seq)	seq：要转换为列表的元组或字符串
dict(x)	将对象如(a=1, b=2, c=3)转换为一个字典
set(x)	将对象x转换为一个无序不重复的元素集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

示例1：

>>> int("100")
100
>>> float(100)
100.0
>>> str(100.0)
'100.0'
>>> complex(100)
(100+0j)
>>> repr(1+1)
'2'
>>> eval("1+1")
2

示例2：tuple()

>>> tuple()  # 创建空元组
()
>>> tuple([1, 2, 3])  # 传入列表
(1, 2, 3)
>>> tuple("www")  # 拆分每个字符
('w', 'w', 'w')
>>> tuple({1: 2, "a": 2})  # 仅返回字典的键
(1, 'a')
>>> tuple((1, 2 ,3))  # 传入元组
(1, 2, 3)
>>> tuple({"a", 2, 3})  # 传入集合
(2, 3, 'a')

示例3：list()

>>> li = list()  # 创建空列表
>>> li
[]
>>> list((1, "a"))  # 传入元组
[1, 'a']
>>> list([1, 2])  # 传入列表
[1, 2]
>>> list("abcd")  # 传入字符串
['a', 'b', 'c', 'd']
>>> list({1:2, "a":3})  # 传入字典，仅返回键
[1, 'a']
>>> list({1, 2, 3})  # 传入集合
[1, 2, 3]

示例4：set()

>>> set("aabc")  # 传字符串
{'a', 'c', 'b'}
>>> 
>>> set([1, 1, "a"])  # 传列表
{1, 'a'}
>>> 
>>> set((1, 2, 2))  # 传元组
{1, 2}
>>> 
>>> set({1, 2, 2})  # 传集合
{1, 2}
>>> 
>>> set({1:2, 2:3})  # 传字典，仅返回键
{1, 2}

  示例4：dict()

>>> dict()  
{}
>>> 
>>> dict({1: 2, 2: 3})  # 传一个字典
{1: 2, 2: 3}
>>>   
>>> dict(one=2, two=3)  # 传关键字（等号前只能是字母）
{'one': 2, 'two': 3}
>>> 
>>> dict([(1, 2), ("a", 2)])  # 传包含一个或多个元组的列表
{1: 2, 'a': 2}
>>> 
>>> dict(zip(["one", "two"], [1, 2]))  # 传zip函数
{'one': 1, 'two': 2}

 

4. 运算符

4.1 算数运算符

运算符	描述	实例
+	加	两个对象相加
-	减	得到负数或是一个数减去另一个数
*	乘	两个数相乘，或是返回一个被重复若干次的字符串
/	除	x 除以 y
//	取整除	返回商的整数部分
%	取余	返回除法的余数
**	幂	返回x的y次幂

 

>>> 3/2
1.5
>>> 3//2
1
>>> 3%2
1
>>> 3**2
9

 

4.2 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b，将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值(Python3.8 版本新增运算符)	在这个示例中，赋值表达式可以避免调用 len() 两次: if(n := len(a))>10:print(f"List is too long ({n} elements, expected <= 10)")

注意 x += y 与 x = x + y 的区别： 

• x += y 不会创建新的对象
• x = x + y 会创建新的对象

>>> a = [1, 2]
>>> id(a)
16101608
>>> a += [3]
>>> a
[1, 2, 3]
>>> id(a)
16101608  # 仍是相同id
>>>
>>> a = a + [4]
>>> a
[1, 2, 3, 4]
>>> id(a)
16002920  # 此时id已改变

 

4.3 位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13 二进制格式如下：

a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~a = 1100 0011

 

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

注意：如果一个操作数A连续异或同一个操作数两次，那么结果还是操作数A。异或的元素的顺序不影响最终结果。

 

4.4 比较（关系）运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3，b=3，则（a == b) 为 true。
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1，b=3，则(a != b) 为 true。
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1，b=3，则(a <> b) 为 true。
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7，b=3，则(a > b) 为 true。
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7，b=3，则(a < b) 为 false。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3，b=3，则(a >= b) 为 true。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3，b=3，则(a <= b) 为 true。

 

注意 == 与 is 的区别：

• == 检查的是两个操作数的值（内容）是否相等
• is 检查的是两个操作数的内存地址是否相同，即两个引用是否指向同一个对象

>>> a = [1, 2]
>>> b = [1, 2]
>>> a == b
True  # 元素值相同，因此为真
>>> a is b
False  # 内存id不同，因此为假

 

4.5 逻辑运算符

运算符	逻辑表达式	描述
and	x and y	从左到右计算表达式，遇到一个假时，满足一假俱假，不在执行后面的语句，返回第一个假值；若所有的都为真，则返回最后一个值。
or	x or y	从左到右计算表达式，只要遇到一个真值时，满足一真俱真，不再执行后面的语句，返回第一个真值；若所有的都为假，则返回最后一个假值。
not	not x	布尔"非"，如果 x 为 True，返回 False ；如果 x 为 False，它返回 True。

 

>>> 1 and 0 and 2
0
>>> 1 and 2 and 3
3
>>> 0 or 1 or 2
1
>>> 0 and {} and None
0
>>> 0 or {} or ()
()

 

练习题

Python 中如何交换两个变量的值？

>>> # 方法一：利用第三个变量
>>> a = 2
>>> b = 3
>>>
>>> c = a
>>> a = b
>>> b = c
>>> a
3
>>> b
2
>>> # 方法二：利用算术运算符
>>> a = 2
>>> b = 3
>>>
>>> a = a + b
>>> b = a - b
>>> a = a - b
>>> a
3
>>> b
2
>>> # 方法三：Python独有的赋值方式
>>> a = 2
>>> b = 3
>>> a, b = b, a
>>> a
3
>>> b
2
>>> # 方法四：使用异或
>>> a = 2
>>> b = 3
>>> a = a^b
>>> b = a^b  # == a^b^b == a
>>> a = a^b  # == a^b^a^b^b == b 
>>> a
3
>>> b
2