解密Python数据类型: 入门指南

一、数值类型

（一）整数（int）

整数包括二进制、八进制、十进制、十六进制等4种表示形式；
二进制：以0b或0B开头：0b1101,0B10;
八进制：以0o或0O开头：0o456,0O789;
十进制：123；
十六进制：以0x或0X开头：0x1A,0X2B。

使用bin(十进制)，可以返回十进制对应的二进制

使用oct(十进制)，可以返回十进制对应的八进制

使用hex(十进制)，可以返回十进制对应的十六进制

#二进制
# 22
a = 0b10110
print(a, type(a))
# 1111000
a = 120
print(bin(a))

#十六进制
#164
a = 0xa4
print(a)
#0x78
a = 120
print(hex(a))

#八进制
#28
a = 0o34
print(a)
#0o170 
a = 120
print(oct(a))

 字符串，浮点数以及布尔值可以转整数，例如：

# 字符串转整数
print(int("123"))
# 浮点数转整数
print(int(11.2))
# 布尔值转整数
print(int(True))

 

（二）浮点数（float）

浮点数包括常规方法和科学计数法2种方式表示；

科学计数法使用字母e或E作为幂的符号，如：0.0043 = 4.3e-3     ；  98000000.0 = 9.8E7

整数，字符串，布尔值可以转成浮点数，例如：

# 整数转浮点数
print(float(1))
# 字符串转浮点数
print(float("12"))
# 布尔值转浮点数
print(float(False))

二、字符串类型

1.字符串定义

字符串：由0个或多个字符组成的有序字符序列，由一对单引号(' ')或一对双引号(" ")表示，可对字符进行索引，用序号进行访问。

表示方法：由一对单引号或双引号表示，仅表示单行字符串，单引号和双引号交替使用；由一对三单引号或三双引号表示，可表示多行字符串。

2.字符串类型转换

所有的数据类型都可转字符串，例如：

# 整数转字符串
a = str(1)
print(str(a), type(a))
# 浮点数转字符串
a = str(3.14)
print(a, type(a))
# 布尔值转字符串
a = str(True)
print(a)
# 空值转字符串
a = str(None)
print(a)

3.字符串的操作

1.字符串查找

使用 .find() 方法来查找字符串中的子串。若查找字符不在字符串中则返回-1

 print("Hello, World!".find("World")) # 输出: 7

使用 .rfind() 方法来查找字符串中的子串。

# 查找从右边第一个出现子串的索引

print("Hello, World!".rfind("o")) # 输出: 8

使用.index(),.rindex()方法查找字符串中的子串,若查找字符不在字符串中则报错。

# 查找字符 'o' 第一次出现的位置
print("Hello, World!".index("o")) # 输出: 4
# 查找最右边字符 'o' 出现的位置
print("Hello, World!".rindex("o")) # 输出: 8

 

2. 查看字符出现的次数

print("Hello, World!".count("o")) # 2

3.大小写转换 

# 首字母大写
print("abcd efg".capitalize()) # Abcd efg
# 转大写
print("aDSdf".upper()) # ADSDF
# 转小写
print("DSWd".lower()) # dswd
# 大小写转换
print("afEd".swapcase()) # AFeD
# 单词首字母大写
print("abc xde".title()) # bc Xde

 4.排列

# 居中， 剩下字符用“+”填充
print("醒醒".center(20, "+"))
# 靠左显示,剩下字符用“+”填充
print("醒醒".ljust(20, "+"))
# 靠右显示,剩下字符用“+”填充
print("醒醒".rjust(20, "+"))
# 靠右，用0填充
print("醒醒".zfill(20))

 5.开始、结尾

# 以“共和国”结尾 True
print("中华人民共和国合同法共和国".endswith("共和国"))
# 以“中华”结尾 True
print("中华人民共和国合同法共和国".startswith("中华"))

6. 编码、解码

bytes_result = "中华人民共和国合同法".encode(encoding="gbk")
print(type(bytes_result), bytes_result)
str_result = bytes_result.decode(encoding="gbk")
print(type(str_result), str_result)

 7.切割与拼接

# 拆分,返回列表
r = "中华人民共和国合同法".split("共和国")
print(type(r), r)
# 拼接
print("++".join(r))

 8.替换

print("中华人民共和国合同法".replace("合同法", "刑法"))

9.是否是

# 是否是字母
print("abc".isalpha())
# 是否是数字
print("123".isdigit())

 10.strip

# 删除空格
print("   admin    ".strip())
# 删除右侧空格
print("   admin     ".rstrip())

三、空值（None）

在Python中，空值表示没有值的情况，它用关键字 None 来表示。None 是一个特殊的常量对象，用于表示空值或者缺失值。

特点和用途

1.表示缺失或空值：

• None 通常用于变量初始化，或者表示一个函数没有明确的返回值。

2.作为默认返回值：

• 如果函数没有显式返回值，Python会默认返回 None。

3.判断空值：

• 可以使用 is 关键字来判断一个变量是否为 None。

  x = None
  
  if x is None:
      print("x is None")
  else:
      print("x is not None")

四、布尔值

在Python中，布尔类型（Boolean type）表示逻辑值，只有两个可能的取值：True 和 False。布尔类型通常用于条件判断、逻辑运算以及控制程序的流程。

特点和用途

1.两个取值：

• True 表示真，用于表示逻辑上的真实情况。
• False 表示假，用于表示逻辑上的不真实情况。

2.逻辑运算：

•  布尔类型常用于逻辑运算符号，如逻辑与 (and)、逻辑或 (or)、逻辑非 (not) 等。

x = True
y = False

print(x and y)  # 输出 False
print(x or y)   # 输出 True
print(not x)    # 输出 False

3.比较运算：

• 比较运算符 (<, >, ==, != 等) 的结果是布尔值。

a = 5
b = 10

print(a < b)   # 输出 True
print(a == b)  # 输出 False

4.条件语句：

• 条件语句 (if, else, elif) 的条件部分需要一个布尔表达式，根据其值来决定程序的执行流程。

  age = 20
  
  if age >= 18:
      print("You are an adult.")
  else:
      print("You are not yet an adult.")

五、组合类型

（一）元组(tuple)

1.元组的定义

定义元组的方式有两种：第一种是使用小括号()表示，元素间用逗号分隔，小括号可以省略。

t1 = (10, 20, 30, 40)
print(t1, type(t1))
t2 = 10,
print(t2, type(t2))
t3 = 10, 20, 30
print(t3, type(t3))

 

第二种方式是将可迭代类型依次放入元组

t4 = tuple("hello")
print(t4, type(t4))
t5 = tuple([10, 20, 30])
print(t5, type(t5))
t6 = tuple(range(10))
print(t6, type(t6))

 

任意数据类型都可放在元组中

t7 = (10, 3.14, "hello world", False, True, None, [], t6)
print(t7, type(t7))

 2.元组的常见操作

（1）查找元素对应的索引

使用index方法查找，返回元素对应的索引,找不到报错

t8 = (1,2,3,4)
print(t8.index(3))# 2

（2）统计元素出现次数

使用count方法返回元素出现的次数,找不到返回0

t9 = (1,2,3,4,5,4)
print(t9.count(4))# 2

（二）列表

1.列表的定义

在Python中，列表是一种有序的可变容器，可以存储任意类型的元素。 定义列表的方式有两种，第一种是用方括号 [] 来表示，并且元素之间用逗号隔开。例如，一个包含整数的列表可以定义如下：

my_list = [1, 2, 3, 4, 5]

第二种方式是将可迭代类型转换成列表，例如：

l1 = list()
print(l1, type(l1))
l2 = list("hello world")
print(l2, type(l2))
l3 = list(range(10))
print(l3, type(l3))

2.列表的遍历

列表的遍历也有两种方式，第一种是不关注索引直接获取元素，第二种是关注索引通过索引获取列表内容，例子如下：

l4 = [a, f, b, s, n]
#  直接获取元素 不关注索引
for e in l4:
    print(e)
# 关注索引通过索引获取列表内容
for i in range(len(l4)):
    print(i, l4[i])

 

3.列表的常见操作

l = [1,2,3]
# 添加到末尾
l.append(7)
print(l)
# 在指定位置插入指定元素
l.insert(1,2)
print(l)
# 将可迭代元素的每一个元素依次添加到列表末尾
l.extend(range(10))
print(l)
# 删除末尾,返回被删除的元素
r = l.pop()
print(r,l)
# 删除指定索引对应的元素,返回被删除的元素
r = l.pop(2)
print(r,l)
# 删除指定的第一次出现的值,不存在就报错
l.remove(2)
print(l)
# 清空列表
# l.clear()
# 查找元素的索引，找不到报错
r = l.index(1)
print(r)
# 统计元素出现的次数
r = l.count(1)
print(r)
# 逆序
l.reverse()
print(l)
# 排序-升序
l.sort()
print(l)
# 排序-降序
l.sort(reverse=True)
print(l)

（三）集合

1.集合的定义

集合是由一组确定的对象所组成的，这些对象被称为集合的元素。集合可以用大括号 {} 表示，元素被放在大括号中，用逗号分隔。

定义集合有两种方式，例子如下：

# 定义集合
# 方式一：不能定义空集合
s0 = {1}
print(s0,type(s0))
# 方式二：
# 定义空集合
s1 = set()
print(s1,type(s1))
# 将可迭代类型依次放入集合
s2 = set(range(10))
print(s2,type(s2))

 结果如下：

 2.集合的常见操作

集合是一种无序且不重复元素的数据结构，常见的操作有：

（1）.添加元素：可以使用add()方法将元素加入集合中，也可使用update()方法。

s4 = {1,2,3}
s4.add(4)
print(s4)
 
s4.update({3,5,7,9})
print(s4)

（2）.删除元素：可以使用remove()方法删除指定元素（如果不存在报错），或者使用discard()方法删除指定元素（如果不存在不报错）。

s4 = {1,2,3,4}
s4.discard(1)
print(s4)
 
s4.remove(2)
print(s4)

 

（3）.长度计算：可以使用len()方法计算集合的元素数量。

s4 = {1,2,3,4}
print(len(s4)) # 4

（4）.判断成员：可以使用in关键字判断一个元素是否存在于集合中。

s4 = {1,2,3,4}
print(4 in s4) # True

（5）.集合运算：可以进行交集、并集、差集和对称差等运算，可以使用intersection()方法计算交集，使用union()方法计算并集，使用difference()方法计算差集，使用symmetric_difference()方法计算对称差。

s5 = {1,3,2,5}
s6 = {3,5,7}
# 交集 两者都有
s7 = s5.intersection(s6)
print(s7)
# 并集 一方有即可
s8 = s5.union(s6)
print(s8)
# 差集
s9 = s5.difference(s6)
print(s9)

 

（6）.清空集合：可以使用clear()方法清空集合中的所有元素。

# 清空
s4.clear()
print(s4)

 

（7）.遍历集合：可以使用for循环遍历集合中的所有元素。

s1 = {1,2,3}
for e in s1:
    print(e)

 

（四）字典

1.字典的定义

定义字典的方式有两种，一种是可以使用花括号 {} 和冒号 : 来创建一个字典，每个键值对用逗号分隔。，第二种是将可迭代类型转换成字典

d1 = {
    "name":"jason",
    "age":42
}
print(d1,type(d1))

d2 = dict(a=10, b=20, c=30)
print(d2,type(d2))

 

2.字典的常见操作

# in 成员运算符
d6 ={
    "id":101
}
d6["name"] = "马云"
print("name" in d6)
print(len(d6))
print("id" in d6)


# 遍历
# 遍历所有的键
for k in d6.keys():
    print(k,d6[k])
# 遍历所有的值
for v in d6.values():
    print(v)
# 遍历所有键值对
for k,v in d6.items():
    print(k,v)

# 获取指定键对应的值 ，如果键不存在返回None,也可指定键不存在时返回默认的值
print(d6.get("id"))
# 如果键不存在返回None
print(d6.get("name"))
# 可指定键不存在时返回默认的值
print(d6.get("name","zs"))
print(d6)
# 添加
d6["name"]= "zs"
print(d6)
# 删除
# 删除指定的键并返回对应的值
d6.pop("name")
print(d6)
# 删除并返回（元组）最后放入的一个键值对，一般不关注字典键值对的先后顺序
d6.popitem()
print(d6)
# 清空
d6.clear()
print(d6)
# 合并一个字典到原始字典
d7 = {
    "sex":"女"
}
d6.update(d7)
print(d6)