Python：常用的数据类型
目录
1. Number（数字类型）
1.1 支持四种不同的数值类型
1.2 数字类型转换
1.3 数字运算
2. bool 布尔类型
2.1bool()的使用
2.2布尔类型运算
3.String（字符串）
3.1字符串创建
3.2 访问字符串中的值
3.3 字符串更新
4.List（列表）
4.1 列表创建
4.2 访问列表中的值
4.3 更新/删除列表
5.Tuple（元组）
5.1 元组创建
5.2 访问元组中的值
5.3 元组运算
6.Set（集合）
6.1 集合创建
6.2 集合操作
6.2.1 添加元素
6.2.2 移除元素
6.2.3 计算集合元素个数
6.2.4 判断元素是否在集合中存在
6.2.5 清空集合
6.3 集合运算
7.Dictionary（字典）
7.1 字典创建
7.2 访问字典里的值
7.3 修改字典
7.4 删除字典元素
1. Number（数字类型）
Python Number 数据类型用于存储数值。
1.1 支持四种不同的数值类型
1）整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
2）长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L （注：只适用于python2，python3不区分，只有一种整数类型Int）
3）浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示
4）复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
a1 = 1 #整型
#a2 = 51924361L #长整型-仅支持于python2
a3 = 1.2 #浮点型
a3_1 = 2.5e2
a4 = 3.14j #复数
print(a1, a3, a3_1, a4) |
1.2 数字类型转换
1）int(x) 将x转换为一个整数。
2）float(x) 将x转换到一个浮点数。
3）complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
4）complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
# 数字类型转换
a5 = 1.0
int(a5)
a6 = int(a5)
print(a5)
print(a6)
print(type(a5)) #'float'
print(type(a6)) #'int'
|
1.3 数字运算
1）运算符：+，-， *， / ，//，**，=
2） / ：返回一个浮点数
3） // ：只想得到整数的结果，丢弃可能的分数部分。// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
4）= ：用于给变量赋值
5）** ：幂运算
6）不同类型的数混合运算时会将整数转换为浮点数
# 数字运算
b1 = 1+2 #3
b2 = 50-10 #40
b3 = 2*4 #8
b4 = 12/3 #4.0 返回一个浮点数
b5 = 13/3 #4.333333333333333 整数除法返回浮点型
b6 = 13//3 #4 整数除法返回向下取整后的结果
b7 = 3*2+5 #11
b8 = 3**2 #3的2次方
print(b1, b2, b3, b4, b5, b6, b7, b8)
|
2. bool 布尔类型
布尔(bool)是整型的子类型。
在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。 在Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字进行相加减乘除。
2.1bool()的使用
print("====布尔值验证====")
b1 = 0
print(bool(b1)) # False
b2 = 0.0
print(bool(b2)) # False
b3 = -0.0
print(bool(b3)) # False
b4 = {}
print(bool(b4)) # False
b5 = []
print(bool(b5)) # False
b6 = 1
print(bool(b6)) # True
b7 = -1
print(bool(b7)) # True
b8 = ''
print(bool(b8)) # False
b9 = ""
print(bool(b9)) # False
b10 = "False"
print(bool(b10)) # True
b11 = 'False'
print(bool(b11)) # True
b12 = None
print(bool(b12)) # False
b13 = False
print(bool(b13)) # False
b14 = True
print(bool(b14)) # True
b15 = bool(10 > 9)
print(bool(b15)) # True
|
2.2布尔类型运算
1）and：与运算，只有所有表达式都为True，and运算的结果才是True
c1 = True and False
print(c1) # False
c2 = True and True
print(c2) # True
c3 = False and False
print(c3) # False
|
2）or：或运算，只要其中一个表达式为True，or运算的结果就为True
c4 = True or False
print(c4) # True
c5 = True or True
print(c5) # True
c6 = False or False
print(c6) # False
|
3）not：非运算，它是单目运算符（只对一个变量进行操作），把True变成False，把False变成True
c7 = not True
print(c7) # False
c8 = not False
print(c8) # True
c9 = not 1 > 2
print(c9) # True
|
4）四则运算时，True的值为1，False的值为0
# false 0 true 1
b7 = -1
b16 = 10 + bool(b7)
print(bool(b16)) # True
print(b16) # 11
b17 = True + 1 # 2
print(b17)
b18 = False + 1 # 1
print(b18)
|
3.String（字符串）
3.1字符串创建
1）Python 中最常用的数据类型。使用引号( ' ' 或 " " )来创建字符串
c1 = ''
c2 = ""
c3 = 'hello'
c4 = "python3 String"
|
3.2 访问字符串中的值
1）访问子字符串，可以使用方括号 [ ] 来截取字符串，格式：变量[头下标:尾下标]
2）索引值以 0 为开始值，-1 为从末尾的开始位置
c3 = 'hello'
c4 = "python3 String"
print("c3[0]:", c3[0]) # h
print("c3[1:4]:", c3[1:4]) # ell
print("c3[1:]:", c3[1:]) # ello
print("c3[:4]:", c3[:4]) # hell
print("c4[-1]:", c4[-1]) # g
print("c4[-8:-1]:", c4[-8:-1]) # 3 Strin
|
3.3 字符串更新
# 字符串更新
c4 = "python3 String"
c5 = c4[:8] + "Update"
print(c5) # python3 Update
|
4.List（列表）
List 可以修改可以删除，可以访问查询
4.1 列表创建
1）列表使用方括号 [ ]
l1 = ['python', 'gongKongMall', 2022, 1999]
l2 = [0, 1, 2, 3, 4, 5]
l3 = ["a", "b", "c", "d"]
l4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
|
4.2 访问列表中的值
1）列表索引从 0 开始，依次1，2，依此类推。通过索引列表可以进行截取、组合等操作。
2）索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。
3）支持使用 [] 截取字符
l1 = ['python', 'gongKongMall', 2022, 1999]
print(l1[0]) # python
print(l1[1]) # gongKongMall
print(l1[3]) # 1999
print(l1[-1]) # 1999
print(l1[-2]) # 2022
print(l1[-4]) # python
# 截取字符
l5 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(l5[0:4]) #[10, 20, 30, 40]
# 从第二位开始（包含）截取到倒数第二位（不包含）
print("l4[1:-2]: ", l4[1:-2]) # ['green', 'blue', 'yellow']
|
4.3 更新/删除列表
# 更新列表
l1 = ['python', 'gongKongMall', 2022, 1999]
l2 = [0, 1, 2, 3, 4, 5]
l2[2] = 'update list'
print(l2) # [0, 1, 'update list', 3, 4, 5]
l1.append('test update')
print(l1) # ['python', 'gongKongMall', 2022, 1999, 'test update']
# 删除
del l1[2]
print(l1)
|
5.Tuple（元组）
Tuple 元素值不允许修改，不允许删除，可以访问查询
5.1 元组创建
1）元组使用小括号 ( )，逗号隔开；不需要括号也可以。
2）元组中只包含一个元素时，需要在元素后面添加逗号 “,” ，否则括号会被当作运算符使用
t0 = ()
t1 = ('python', 'gongKongMall', 2022, 1999)
t2 = (0, 1, 2, 3, 4, 5)
t3 = "a", "b", "c", "d" # 不需要括号也可以
t4 = ('red', 'green', 'blue', 'yellow', 'white', 'black')
t5 = (50)
t6 = (50,)
print(type(t5)) # |
5.2 访问元组中的值
1）正向索引：索引从 0 开始，依次1，2，依此类推。可以进行截取、组合等操作。
2）反向索引：索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。
3）截取使用 []
t1 = ('python', 'gongKongMall', 2022, 1999)
print(t1[0]) # python
print(t1[1]) # gongKongMall
print(t1[-1]) # 1999
print(t1[-2]) # 2022
print(t1[-4]) # python
# 截取字符
t7 = (10, 20, 30, 40, 50, 60, 70, 80, 90)
print(t7[0:4]) # (10, 20, 30, 40)
print("l4[1:-2]: ", t4[1:-2]) # ('green', 'blue', 'yellow')
|
5.3 元组运算
1）元组之间可以使用 + 号和 * 号进行运算。
tup1 = len((1, 2, 3))
print(tup1) # 3
tup2 = (1, 2, 3) + (4, 5, 6)
print(tup2) # (1, 2, 3, 4, 5, 6)
tup3 = ('Hi!',) * 4
print(tup3) # ('Hi!', 'Hi!', 'Hi!', 'Hi!')
3 in (1, 2, 3)
for x in (1, 2, 3):
print(x, end=" ") # 1 2 3 |
6.Set（集合）
6.1 集合创建
1）集合（set）是一个无序的不重复元素序列。
2）使用大括号 { } 或者 set() 函数创建集合。
3）创建空集合用 set() ，不能用 { }。
set() # 空集合必须用set()，不能用{}
s1 = {'python', 'gongKongMall', 2022, 1999} |
6.2 集合操作
6.2.1 添加元素
1）s.add( x ) ：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
2）s.update( x ) ：也可以添加元素，且参数可以是列表，元组，字典等。x 可以有多个，用逗号分开。
s1.add('10086')
print(s1) # 无序 {'python', '10086', 2022, 'gongKongMall', 1999}
s1.update('gks')
print(s1) # {2022, 1999, 'gongKongMall', 's', '10086', 'k', 'g', 'python'}
s1.update({11, 33})
print(s1) # {'10086', 33, 'g', 2022, 'python', 11, 1999, 's', 'k', 'gongKongMall'}
s1.update([1, 4], [5, 6])
print(s1) # {'s', 33, 1, 'gongKongMall', 'g', 2022, 4, 5, 6, 'python', 'k', 11, '10086', 1999} |
6.2.2 移除元素
1）s.remove( x ) ：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
2）s.discard( x )：如果元素不存在，不会发生错误。
3）s.pop()：随机删除集合中的一个元素。pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
s1.remove(33)
# s1.remove('33') # '33'不存在 移除报错
print(s1) # {1, 's', 4, 5, 2022, 6, 11, 1999, '10086', 'g', 'k', 'python', 'gongKongMall'}
s1.discard(11)
s1.discard('33') # '33'不存在 移除不报错
print(s1) # {'10086', 's', 1, 4, 2022, 5, 6, 1999, 'g', 'k', 'gongKongMall', 'python'}
s2 = s1.pop() # 随机删除, 选择无序排列的第一个元素 删除
print(s2) |
6.2.3 计算集合元素个数
1）len(s) ：计算集合元素个数
s3 = len(s1)
print(s3) # 11 |
6.2.4 判断元素是否在集合中存在
1） x in s ：判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
'python' in s1 # True
'2021' in s1 # False |
6.2.5 清空集合
1）s.clear() ：清空集合 s。
s1.clear()
print(s1) # set() |
6.3 集合运算
a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'd', 'b', 'a', 'c'}
s4 = a - b # 集合a中包含而集合b中不包含的元素
print(s4) # {'r', 'd', 'b'}
s5 = a | b # 集合a或b中包含的所有元素
print(s5) # {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
s6 = a & b # 集合a和b中都包含了的元素
print(s6) # {'a', 'c'}
s7 = a ^ b # 不同时包含于a和b的元素
print(s7) # {'r', 'd', 'b', 'm', 'z', 'l'} |
7.Dictionary（字典）
7.1 字典创建
1）d = {key1 : value1, key2 : value2, key3 : value3 }：字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在 {} 中。
2）键必须是唯一的，但值则不必。
3）值可以取任何数据类型，但键必须是不可变的，如字符串，数字，不可以用列表。
4）d ={ } ：空字典。
5）d = dict() ：使用函数dict()创建字典。
d = {} # 空字典
print(type(d)) # |
7.2 访问字典里的值
print(d2["loginName"]) # 0002
print(d2["operation"]) # True
# print(d2["pwd"]) # 访问不存在的报错 |
7.3 修改字典
d2["loginName"] = "0006"
print(d2["loginName"]) # 0006
d2["tel"] = "6886888"
print(d2) |
7.4 删除字典元素
del d2["deviceId"] # 删除键 "deviceId"
d2.clear() # 清空字典
del d2 # 删除字典
# print(d2["deviceId"] ) # 删除后访问会引发异常
|