【Python-数据类型】

Python-数据类型

• [■ 类型简介](#■ 类型简介)
• [■ Number（数字）](#■ Number（数字）)
• [■ String（字符串）](#■ String（字符串）)
• • [■ Python 转义字符](#■ Python 转义字符)
  • [■ Python 字符串运算符](#■ Python 字符串运算符)
  • [■ Python 字符串格式化](#■ Python 字符串格式化)
  • [■ Python三引号](#■ Python三引号)
  • [■ f-string](#■ f-string)
• [■ bool（布尔类型）](#■ bool（布尔类型）)
• [■ List（列表）](#■ List（列表）)
• • [■ 列表索引从 0 开始，第二个索引是 1](#■ 列表索引从 0 开始，第二个索引是 1)
  • [■ 从尾部开始，最后一个元素的索引为 -1，往前一位为 -2](#■ 从尾部开始，最后一个元素的索引为 -1，往前一位为 -2)
  • [■ 方括号 [] 的形式截取字符](#■ 方括号 [] 的形式截取字符)
  • [■ 添加列表项（append() ）](#■ 添加列表项（append() ）)
  • [■ 删除列表元素（del 语句）](#■ 删除列表元素（del 语句）)
  • [■ 脚本操作符](#■ 脚本操作符)
  • [■ 列表截取与拼接](#■ 列表截取与拼接)
  • [■ 嵌套列表](#■ 嵌套列表)
  • [■ 列表比较](#■ 列表比较)
  • [■ 列表函数&方法](#■ 列表函数&方法)
• [■ tuple（元组）](#■ tuple（元组）)
• • [■ 示例](#■ 示例)
  • [■ 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：](#■ 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：)
  • [■ 元组下标索引](#■ 元组下标索引)
  • [■ 访问元组](#■ 访问元组)
  • [■ 修改元组](#■ 修改元组)
  • [■ 删除元组](#■ 删除元组)
  • [■ 元组运算符](#■ 元组运算符)
  • [■ 元组索引，截取](#■ 元组索引，截取)
  • [■ 元组内置函数](#■ 元组内置函数)
• [■ Set（集合）](#■ Set（集合）)
• • [■ 实例演示：](#■ 实例演示：)
  • [■ 添加元素 add()](#■ 添加元素 add())
  • [■ 添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典](#■ 添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典)
  • [■ 移除元素 s.remove( x )](#■ 移除元素 s.remove( x ))
  • [■ 移除集合中的元素s.discard( x )](#■ 移除集合中的元素s.discard( x ))
  • [■ 随机删除集合中的一个元素](#■ 随机删除集合中的一个元素)
  • [■ 计算集合元素个数 len(s)](#■ 计算集合元素个数 len(s))
  • [■ 清空集合 s.clear()](#■ 清空集合 s.clear())
  • [■ 判断元素是否在集合中存在 （x in s）](#■ 判断元素是否在集合中存在 （x in s）)
  • [■ 集合内置方法完整列表](#■ 集合内置方法完整列表)
• [■ dict （字典）Dictionary](#■ dict （字典）Dictionary)
• • [■ 示例 键值 key](#■ 示例 键值 key)
  • [■ 键值可以是数字，数据可以取任何数据类型加粗样式](#■ 键值可以是数字，数据可以取任何数据类型加粗样式)
  • [■ 空字典](#■ 空字典)
  • [■ 访问字典里的值](#■ 访问字典里的值)
  • [■ 修改字典](#■ 修改字典)
  • [■ 删除字典元素](#■ 删除字典元素)
  • [■ 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行](#■ 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行)
  • [■ 字典内置函数&方法](#■ 字典内置函数&方法)
• [■ 数据类型函数](#■ 数据类型函数)
• • [■ 数学函数](#■ 数学函数)
  • [■ 随机数函数](#■ 随机数函数)
  • [■ 三角函数](#■ 三角函数)
  • [■ 数学常量](#■ 数学常量)
  • [■ type() 查询变量所指的对象类型](#■ type() 查询变量所指的对象类型)
  • [■ isinstance（）判断类型](#■ isinstance（）判断类型)
  • [■ isinstance 和 type 的区别在于：](#■ isinstance 和 type 的区别在于：)
  • [■ 数字运算](#■ 数字运算)
  • [■ 数学函数](#■ 数学函数)
  • [■ 随机数函数](#■ 随机数函数)
  • [■ 三角函数](#■ 三角函数)
  • [■ 数学常量](#■ 数学常量)

■ 类型简介

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

#!/usr/bin/python3

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

输出如下
100
1000.0
runoob

■ Number（数字）

支持 int、float、bool、complex（复数）。

内置的 type() 函数可以用来查询变量所指的对象类型。

Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

>>> 17 / 3 	 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 7 // 2
3
>>> 7.0 // 2
3.0 
>>> 7 // 2.0
3.0
>>> 17 % 3    # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

操作来进行幂运算：
>>> 5 ** 2   #5 的平方
25
>>> 2 ** 7   #2的7次方
128

不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

■ String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

变量[头下标:尾下标]

#!/usr/bin/python3

str = 'Runoob'  # 定义一个字符串变量
print(str)         	 # Runoob  			# 打印整个字符串 
print(str[0:-1])   	 # Runoo  			# 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])      	 # R  				# 打印字符串的第一个字符
print(str[2:5])    	 # noo  			# 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])    	 # noob  			# 打印字符串从第三个字符开始到末尾
print(str * 2)     	 # RunoobRunoob  	# 打印字符串两次
print(str + "TEST")  # RunoobTEST  		# 打印字符串和"TEST"拼接在一起

■ Python 转义字符

runoob

■ Python 字符串运算符

runoob

■ Python 字符串格式化

runoob

■ Python三引号

runoob

■ f-string

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

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

■ bool（布尔类型）

■ List（列表）

■ 列表索引从 0 开始，第二个索引是 1

list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

print( list[0] )
print( list[1] )
print( list[2] )

实例输出结果：
red
green
blue

■ 从尾部开始，最后一个元素的索引为 -1，往前一位为 -2

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

实例输出结果：
black
white
yellow

■ 方括号 [] 的形式截取字符

#!/usr/bin/python3

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

以上实例输出结果：
[10, 20, 30, 40]

负数索引值截取：

#!/usr/bin/python3

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]

# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

以上实例输出结果：
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

■ 添加列表项（append() ）

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

例输出结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

例输出结果：
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

■ 删除列表元素（del 语句）

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000] 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

实例输出结果：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

■ 脚本操作符

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

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

■ 列表截取与拼接

■ 嵌套列表

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

■ 列表比较

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
以上代码输出结果为：

operator.eq(a,b):  False
operator.eq(c,b):  True

■ 列表函数&方法

■ tuple（元组）

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

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

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

■ 示例

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

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

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

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

■ 元组下标索引

■ 访问元组

#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

■ 修改元组

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

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

实例输出结果：
(12, 34.56, 'abc', 'xyz')

■ 删除元组

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

输出如下所示：
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

■ 元组运算符

■ 元组索引，截取

Python表达式	结果	描述
tup[1]	'Runoob'	读取第二个元素
tup[-2]	'Weibo'	反向读取，读取倒数第二个元素
tup[1:]	('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4]	('Runoob', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', '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，绑定到新的对象了，不是修改了原来的对象。

■ 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 basket
False

>>> # 下面展示两个集合间的运算.
...
>>> 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'}

■ 添加元素 add()

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

■ 添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典

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

■ 移除元素 s.remove( x )

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

■ 移除集合中的元素s.discard( x )

s.discard( x )是移除集合中的元素且如果元素不存在，不会发生错误.

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

■ 随机删除集合中的一个元素

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

输出结果：
Runoob

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

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

■ 清空集合 s.clear()

清空集合 s。

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

■ 判断元素是否在集合中存在 （x in s）

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

■ 集合内置方法完整列表

■ dict （字典）Dictionary

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

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

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

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

■ 示例 键值 key

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

■ 键值可以是数字，数据可以取任何数据类型加粗样式

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

■ 空字典

emptyDict = {} # 使用大括号 {} 来创建空字典

emptyDict = dict() # 使用内建函数 dict() 创建字典

emptyDict = {}  # 使用大括号 {} 来创建空字典
# emptyDict = dict() # 使用内建函数 dict() 创建字典

# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))
以上实例输出结果：

{}
Length: 0
<class 'dict'>

■ 访问字典里的值

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
以上实例输出结果：

tinydict['Name']:  Runoob
tinydict['Age']:  7

■ 修改字典

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"    # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

实例输出结果：
tinydict['Age']:  8
tinydict['School']:  菜鸟教程

■ 删除字典元素

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

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

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

■ 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

#!/usr/bin/python3
 
tinydict = {['Name']: 'Runoob', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

■ 字典内置函数&方法

■ 数据类型函数

■ 数学函数

■ 随机数函数

■ 三角函数

■ 数学常量

■ type() 查询变量所指的对象类型

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

■ isinstance（）判断类型

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

■ isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。

■ 数字运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2

使用 ** 操作来进行幂运算：
>>> 2 ** 5 # 乘方
32
>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128
混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

■ 数学函数

■ 随机数函数

■ 三角函数

■ 数学常量