第3篇| Python运算符与数据类型

1、运算符

什么是运算符？运算用的符号。比如数学上的加减乘除平方等等。

python运算符有哪些类型？

• • 算术运算符
• • 比较（关系）运算符
• • 赋值运算符
• • 逻辑运算符
• • 位运算符
• • 成员运算符
• • 身份运算符
• • 运算符优先级

1.1、算术运算符

运算用的，用法与数学一致。

示例如下：

a = 21b = 10c = 0c = a + bprint ("1 - c 的值为：", c)c = a - bprint ("2 - c 的值为：", c)c = a * bprint ("3 - c 的值为：", c)c = a / bprint ("4 - c 的值为：", c)c = a % bprint ("5 - c 的值为：", c)# 修改变量 a 、b 、ca = 2b = 3c = a**b print ("6 - c 的值为：", c)a = 10b = 5c = a//b print ("7 - c 的值为：", c)# 输出结果1 - c 的值为： 312 - c 的值为： 113 - c 的值为： 2104 - c 的值为： 2.15 - c 的值为： 16 - c 的值为： 87 - c 的值为： 2

1.2、比较运算符

顾名思义，进行比较。

示例如下：

a = 21b = 10c = 0if ( a == b ):   print ("1 - a 等于 b")else:   print ("1 - a 不等于 b")if ( a != b ):   print ("2 - a 不等于 b")else:   print ("2 - a 等于 b")if ( a < b ):   print ("3 - a 小于 b")else:   print ("3 - a 大于等于 b")if ( a > b ):   print ("4 - a 大于 b")else:   print ("4 - a 小于等于 b")# 修改变量 a 和 b 的值a = 5b = 20if ( a <= b ):   print ("5 - a 小于等于 b")else:   print ("5 - a 大于  b")if ( b >= a ):   print ("6 - b 大于等于 a")else:   print ("6 - b 小于 a")# 输出结果1 - a 不等于 b2 - a 不等于 b3 - a 大于等于 b4 - a 大于 b5 - a 小于等于 b6 - b 大于等于 a

1.3、赋值运算符

用于赋值操作，例如a+=1，a自增。

示例如下：

a = 21b = 10c = 0c = a + bprint ("1 - c 的值为：", c)c += aprint ("2 - c 的值为：", c)c *= aprint ("3 - c 的值为：", c)c /= a print ("4 - c 的值为：", c)c = 2c %= aprint ("5 - c 的值为：", c)c **= aprint ("6 - c 的值为：", c)c //= aprint ("7 - c 的值为：", c)# 输出结果1 - c 的值为： 312 - c 的值为： 523 - c 的值为： 10924 - c 的值为： 52.05 - c 的值为： 26 - c 的值为： 20971527 - c 的值为： 99864

1.4、逻辑运算符

示例如下：

a = 10b = 20if ( a and b ):   print ("1 - 变量 a 和 b 都为 true")else:   print ("1 - 变量 a 和 b 有一个不为 true")if ( a or b ):   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:   print ("2 - 变量 a 和 b 都不为 true")# 修改变量 a 的值a = 0if ( a and b ):   print ("3 - 变量 a 和 b 都为 true")else:   print ("3 - 变量 a 和 b 有一个不为 true")if ( a or b ):   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:   print ("4 - 变量 a 和 b 都不为 true")if not( a and b ):   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")else:   print ("5 - 变量 a 和 b 都为 true")# 输出结果1 - 变量 a 和 b 都为 true2 - 变量 a 和 b 都为 true，或其中一个变量为 true3 - 变量 a 和 b 有一个不为 true4 - 变量 a 和 b 都为 true，或其中一个变量为 true5 - 变量 a 和 b 都为 false，或其中一个变量为 false

其它运算符暂且不讲，请自行查阅。

2、数据类型

2.1、数字（Number）

Python 数字数据类型用于存储数值。

Python 支持三种不同的数值类型：

• • 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
• • 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）。
• • 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

数字类型转换：

>>> a = 1.0>>> int(a)    # int()强制转换浮点型（小数）为整形（整数）1       

数字的运算不再赘述，详见算数运算符。

数学函数：

随机数、三角函数不再介绍。

2.2、字符串（String）

字符串定义不再赘述，详见上面介绍，Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

字符串索引（切片），访问字符串中的值。

Python 访问子字符串，可以使用方括号 [ ] 来截取字符串，字符串的截取（切片）的语法格式如下：

变量[起始下标:终止下标:步长]  # 起始下标包括，终止标不包括，步长为每次跨几个。

字符串更新：

var1 = 'Hello World!'     # 注意空格自符串' ',和空字符串''的区别。 print ("已更新字符串 : ", var1[:6] + 'python!')    # + 用于拼接字符串# 输出  已更新字符串 :  Hello python!# 特别注意：空格自符串长度为1，空字符串长度为0

转义字符表：

示例如下：

print('\'Hello, world!\'')  # 输出：'Hello, world!'print("Hello, world!\nHow are you?")  # 输出：Hello, world!                                     #       How are you?print("Hello, world!\tHow are you?")  # 输出：Hello, world!    How are you?print("Hello,\b world!")  # 输出：Hello world!print("Hello,\f world!")  # 输出：                           # Hello,                           #  world!print("A 对应的 ASCII 值为：", ord('A'))  # 输出：A 对应的 ASCII 值为： 65print("\x41 为 A 的 ASCII 代码")  # 输出：A 为 A 的 ASCII 代码decimal_number = 42binary_number = bin(decimal_number)  # 十进制转换为二进制print('转换为二进制:', binary_number)  # 转换为二进制: 0b101010octal_number = oct(decimal_number)  # 十进制转换为八进制print('转换为八进制:', octal_number)  # 转换为八进制: 0o52hexadecimal_number = hex(decimal_number)  # 十进制转换为十六进制print('转换为十六进制:', hexadecimal_number) # 转换为十六进制: 0x2a

字符串运算符：

示例如下：

a = "Hello"b = "Python"print("a + b 输出结果：", a + b)print("a * 2 输出结果：", a * 2)print("a[1] 输出结果：", a[1])print("a[1:4] 输出结果：", a[1:4])if( "H" in a) :    print("H 在变量 a 中")else :    print("H 不在变量 a 中")if( "M" not in a) :    print("M 不在变量 a 中")else :    print("M 在变量 a 中")print (r'\n')print (R'\n')# 输出结果a + b 输出结果： HelloPythona * 2 输出结果： HelloHelloa[1] 输出结果： ea[1:4] 输出结果： ellH 在变量 a 中M 不在变量 a 中\n\n

字符串格式化：

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。示例如下：

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))# 结果      我叫 小明 今年 10 岁!

字符串格式化符号表：

f-string格式化:

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%)：

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))# 结果      我叫 小明 今年 10 岁!

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，示例如下：

name = 'Python'f'Hello {name}'  # 替换变量'Hello Python'f'{1+2}'         # 使用表达式'3' w = {'name': 'Python', 'url': 'www.Python.com'} # 这是字典，键值对 f'{w["name"]}: {w["url"]}''Python: www.Python.com'

format()格式化输出：

format()函数是Python中用于格式化字符串的强大工具，同样使用大括号{}占位，以下简称为“槽”，按“槽”给值，一个萝卜一个坑，基本语法如下：

"字符串{}".format(值)"字符串{}，{}，{}".format(值1，值2，值3)    # {} 槽中不填序号，则从左往右依次填充"字符串{1}，{0}，{2}".format(值2，值1，值3) # {} 槽中填序号，则按序号012依次填充

示例如下：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序'hello world'>>> "{0} {1}".format("hello", "world")  # 设置指定位置'hello world'>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置'world hello world'

2.3、列表（List）

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Python', 1997, 2000]list2 = [1, 2, 3, [4, 5]]list3 = ["a", "b", "c", "d"]list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

列表索引：

与字符串索引一致，下标从0开始（从前往后/从左到右），从后往前索引（右到左）下标从-1（最后（右）边的元素）开始。索引语法如下：

变量[下标]  

示例如下：

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']print( list[0] )print( list[1] )print( list[2] )print( list[-1] )print( list[-2] )print( list[-3] )#    结果redgreenblueblackwhiteyellow

列表切片：

与字符串切片一致，语法如下：

变量[起始下标:终止下标:步长]  # 起始下标包括，终止标不包括，步长为每次跨几个。

切片示例如下：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]print(nums[0:4])# 结果   [10, 20, 30, 40]list = ['Google', 'python', "Zhihu", "Taobao", "Wiki"]# 读取第二位print ("list[1]: ", list[1])# 从第二位开始（包含）截取到倒数第二位（不包含）print ("list[1:-2]: ", list[1:-2])# 结果list[1]:  pythonlist[1:-2]:  ['python', 'Zhihu']

更新列表：

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

list = ['Google', 'Python', 1997, 2000]print ("第三个元素为 : ", list[2])list[2] = 2001print ("更新后的第三个元素为 : ", list[2])list1 = ['Google', 'Python', 'Taobao']list1.append('Baidu')print ("更新后的列表 : ", list1)# 结果第三个元素为 :  1997更新后的第三个元素为 :  2001更新后的列表 :  ['Google', 'Python', 'Taobao', 'Baidu']

删除列表元素：

可以使用 del 语句来删除列表中的元素，示例如下：

list = ['Google', 'python', 1997, 2000]print ("原始列表 : ", list)del list[2]                    # 索引删除print ("删除第三个元素 : ", list)# 结果原始列表 :  ['Google', 'python', 1997, 2000]删除第三个元素 :  ['Google', 'python', 2000]

列表操作符：

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表，如下所示：

列表截取与拼接：

列表截取与字符串操作类似，如下所示：

L=['Google', 'python', 'Taobao']

操作：

>>> L=['Google', 'python', 'Taobao']>>> L[2]'Taobao'>>> L[-2]'python'>>> L[1:]['python', 'Taobao']>>>

列表还支持拼接操作：

>>> squares = [1, 4, 9, 16, 25]>>> squares += [36, 49, 64, 81, 100]   # a+=1  <==>  a=a+1 >>> squares[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表嵌套：

使用嵌套列表即在列表里创建其它列表，例如：

>>> a = ['a', 'b', 'c']>>> n = [1, 2, 3]>>> x = [['a', 'b', 'c'], [1, 2, 3]]>>> x[['a', 'b', 'c'], [1, 2, 3]]>>> x[0]['a', 'b', 'c']>>> x[0][1]'b'

列表比较暂且不讲。

列表常用函数&方法：

2.4、元组（Tuple）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，示例如下：

>>> tup1 = ('Google', 'python', 1997, 2000)>>> tup2 = (1, 2, 3, 4, 5 )>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以>>> type(tup3)<class 'tuple'># 创建空元组tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)>>> type(tup1)     # 不加逗号，类型为整型<class 'int'>>>> tup1 = (50,)>>> type(tup1)     # 加上逗号，类型为元组<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等，示例如下：

tup1 = ('Google', 'python', 1997, 2000)tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])# 结果tup1[0]:  Googletup2[1:5]:  (2, 3, 4, 5)

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，示例如下：

tup1 = (12, 34.56)tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。# tup1[0] = 100  报错# 创建一个新的元组tup3 = tup1 + tup2print (tup3)>>>(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，示例如下：

tup = ('Google', 'python', 1997, 2000)print (tup)del tupprint ("删除后的元组 tup : ")print (tup)>>>删除后的元组 tup : Traceback (most recent call last):  File "test.py", line 8, in <module>    print (tup)NameError: name 'tup' is not defined   # 报错“未定义”

元组运算符：

与字符串一样，元组之间可以使用 +、**+=**和 ***** 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

元组索引、截取（切片）：

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，示例如下：

tup = ('Google', 'python', 'Taobao', 'Wiki', 'Weibo','Weixin')

代码示例如下：

>>> tup = ('Google', 'python', 'Taobao', 'Wiki', 'Weibo','Weixin')>>> tup[1]'python'>>> tup[-2]'Weibo'>>> tup[1:]('python', 'Taobao', 'Wiki', 'Weibo', 'Weixin')>>> tup[1:4]('python', 'Taobao', 'Wiki')

元组的内置函数：

元组不可变的原因：

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')>>> tup[0] = 'g'     # 不支持修改元素  报错Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment>>> id(tup)     # 查看内存地址4440687904>>> tup = (1,2,3)>>> id(tup)4441088800    # 内存地址不一样了

从以上示例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。（对象改变-->内存改变了）

2.5、字典（Dictionary）

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字，示例如下：

tinydict = {'name': 'python', 'likes': 123, 'url': 'www.python.org'}tinydict1 = { 'abc': 456 }tinydict2 = { 'abc': 123, 98.6: 37 }使用大括号 { } 创建空字典：emptyDict = {}# 打印字典print(emptyDict)# 查看字典的数量print("Length:", len(emptyDict))# 查看类型print(type(emptyDict))# 结果{}Length: 0<class 'dict'>使用内建函数 dict() 创建字典：emptyDict = dict()# 打印字典print(emptyDict) # 查看字典的数量print("Length:",len(emptyDict)) # 查看类型print(type(emptyDict))# 结果{}Length: 0<class 'dict'>

访问字典里的值：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}print ("tinydict['Name']: ", tinydict['Name'])print ("tinydict['Age']: ", tinydict['Age'])# 结果tinydict['Name']:  pythontinydict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}print ("tinydict['Alice']: ", tinydict['Alice'])# 结果 报错Traceback (most recent call last):  File "test.py", line 5, in <module>    print ("tinydict['Alice']: ", tinydict['Alice'])KeyError: 'Alice'也可以使用 d.get(‘键’)方法来访问字典的值，如果键名不存在则返回空，如下：   # 其中d为字典名tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}print("tinydict.get['Alice']: ", tinydict.get('Alice'))# 结果tinydict.get['Alice']:  None

删除字典元素：

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，示例如下：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}del tinydict['Name'] # 删除键 'Name'tinydict.clear()     # 清空字典del tinydict         # 删除字典print ("tinydict['Age']: ", tinydict['Age'])   # 结果会报错，因为del删除字典了print ("tinydict['School']: ", tinydict['School'])

2.6、集合（Set）

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

集合创建格式：

parame = {value01,value02,...}或者set(value)

示例如下：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

**注意：**创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

更多示例如下：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket)                      # 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket                 # 快速判断元素是否在集合内True>>> 'crabgrass' in basketFalse>>> # 下面展示两个集合间的运算....>>> a = set('abracadabra')>>> b = set('alacazam')>>> a                                  {'a', 'r', 'b', 'c', 'd'}>>> a - b                              # 集合a中包含而集合b中不包含的元素{'r', 'd', 'b'}>>> a | b                              # 集合a或b中包含的所有元素{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b                              # 集合a和b中都包含了的元素{'a', 'c'}>>> a ^ b                              # 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}

添加元素：

s.add( x ) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "python", "Taobao"))>>> thisset.add("Facebook")>>> print(thisset){'Taobao', 'Facebook', 'Google', 'python'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x ) x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "python", "Taobao"))>>> thisset.update({1,3})>>> print(thisset){1, 3, 'Google', 'Taobao', 'python'}>>> thisset.update([1,4],[5,6])  >>> print(thisset){1, 3, 4, 5, 6, 'Google', 'Taobao', 'python'}>>>

移除元素：

s.remove( x ) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误，示例如下：

>>> thisset = set(("Google", "python", "Taobao"))>>> thisset.remove("Taobao")>>> print(thisset){'Google', 'python'}>>> thisset.remove("Facebook")   # 不存在会发生错误Traceback (most recent call last):  File "<stdin>", line 1, in <module>KeyError: 'Facebook'

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "python", "Taobao"))>>> thisset.discard("Facebook")  # 不存在不会发生错误>>> print(thisset){'Taobao', 'Google', 'python'}

也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

thisset = set(("Google", "python", "Taobao", "Facebook"))x = thisset.pop()print(x)# 结果 python

计算集合元素个数：

len(s) 计算集合 s 元素个数。

>>> thisset = set(("Google", "python", "Taobao"))>>> len(thisset)3

清空集合：

s.clear() 清空集合 s。

>>> thisset = set(("Google", "python", "Taobao"))>>> thisset.clear()>>> print(thisset)set()

判断元素是否在集合中存在：

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "python", "Taobao"))>>> "python" in thissetTrue>>> "Facebook" in thissetFalse>>>