【Python-数据类型】

Python-数据类型

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