类型比较

1. 定义

1. int 整形

整型其实就是十进制整数的统称，比如：1、68、999都属于整型。他一般用于表示年龄、序号等。

2. 布尔类型 bool

布尔值，其实就是 “真”、“假” 。

3. 字符串 str

字符串，我们平时会用他来表示文本信息。例如：姓名、地址、自我介绍等。

4. 列表 list

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

5. 元祖 tuple

元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。
注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

6. 集合 set

v1 = { 11, 22, 33, "alex" }

集合是一个无序、可变、不允许数据重复的容器。
set集合，一个不允许重复重复 & 可变类型（元素可哈希）。
注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

一般什么时候用集合呢？

就是想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。

7. dict 字典

data = { "k1":1,  "k2":2 }

dict字典，一个容器且元素必须是键值对。
字典是无序、键不重复 且元素只能是键值对的可变的 个容器。

容器
元素必须键值对
键不重复，重复则会被覆盖
无序（在Python3.6+字典就是有序了，之前的字典都是无序。）

字典中对键值得要求：

键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）
值：任意类型。

一般在什么情况下会用到字典呢？

当我们想要表示一组固定信息时，用字典可以更加的直观

8. float 浮点

float类型，我们生活中常见的小数。

浮点型，一般在开发中用于表示小数。

在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
想要保留小数点后N位
浮点型的坑（所有语言中）

2. 独有功能

2.1 int

无

2.2 布尔类型

无

2.3 字符串

1. 以 XX 开头 得到一个布尔值

result = v1.startswith("叨逼叨的一天")

2. 以 XX 结尾 得到一个布尔值
result = v1.endswith("烦死了")

3. 是否为十进制数？得到一个布尔值 **判断是否是个整数**
result = v1.isdecimal()

4. 去除字符串两边的空格、换行符、制表符，得到一个新字符串

data = msg.strip() # # 将msg两边的空白去掉
data = msg.lstrip() # # 将msg左边的空白去掉
data = msg.rstrip() # # 将msg右边的空白去掉

5. 大写，得到一个新字符串
data = msg.upper()

6. 小写，得到一个新字符串
data = msg.lower()

7. 内容替换，得到一个新的字符串
value = data.replace("好人","贱人")

8. 切割，得到一个列表
result = data.split('|') # ["武沛齐","root","wupeiqi@qq.com"]
v2 = data.split("|", 2) # ['武沛齐', 'root|wupeiqi@qq.com']
v2 = data.rsplit(',',1) # ['武沛齐,root', 'wupeiqi@qq.com']

9. 拼接，得到一个新的字符串
v1 = "_".join(data_list)

10. 格式化字符串，得到新的字符串
name = "{0}的喜欢干很多行业，例如有：{1}、{2} 等"
data = name.format("老王","护士","嫩模")

11. 字符串转换为字节类型
v1 = data.encode("utf-8") # utf-8，字节类型
v2 = data.encode("gbk") # gbk，字节类型

s1 = v1.decode("utf-8") # 嫂子
s2 = v2.decode("gbk") # 嫂子

12. 将字符串内容居中、居左、居右展示
data = v1.center(21, "-") # # 居中
data = v1.ljust(21, "-") # # 居左
data = v1.rjust(21, "-") # # 居右

13. 帮助你填充0
v1 = data.zfill(10)

2.4 列表（list）

1. 追加，在原列表中尾部追加值。

data_list.append(v1)

2. 批量追加，将一个列表中的元素逐一添加另外一个列表。

tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中

3. 插入，在原列表的指定索引位置插入值

user_list.insert(0,"马蓉")

4. 在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】

user_list.remove("Alex")

5. 在原列表中根据索引踢出某个元素（根据索引位置删除）

user_list.pop() #默认将列表的最后一个值删除

6. 清空原列表

user_list.clear()

7. 根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】

index = user_list.index("Alex")

8. 列表元素排序

num_list.sort() # 让num_list从小到大排序

num_list.sort(reverse=True) # # 让num_list从大到小排序

注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。【布尔类型和整数是可以比较的，但是字符串和整数是无法比较】

9. 反转原列表
user_list.reverse()

2.5 元组（tuple）

无

2.6 集合（set）

1. 添加元素
data.add("郑裕玲")

2. 删除元素
data.discard("关之琳")

3. 交集 取两个集合的交集
s4 = s1.intersection(s2)

4. 并集 取两个集合的并集

s4 = s1.union(s2)
s3 = s1|s2

5. 差集
s4 = s1.difference(s2) #差集，s1中有且s2中没有的值
s3 = s1 - s2 # 差集，s1中有且s2中没有的值

2.7 字典（dict)

1. 获取值
data1 = info.get("name")

data = info.get("email") # 键不存在，默认返回 None

2. 所有的键

data = info.keys()

注意：在Python2中字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

3. 所有的值

data = info.values()

注意：在Python2中字典.values()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

4. 所有的键值

data = info.items()

5. 设置值

data.setdefault("age", 18)

data = {
    "name": "武沛齐",
    "email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data)  # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}

data.setdefault("name", "alex")
print(data)  # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}

6. 更新字典键值对

info.update( {"age":14,"name":"武沛齐"} ) # info中没有的键直接添加；有的键则更新值

7. 移除指定键值对

data = info.pop("age")

8. 按照顺序移除（后进先出）

data = info.popitem() # ("name","武沛齐" )

py3.6后，popitem移除最后的值。
py3.6之前，popitem随机删除。

3.共有功能

1.无公共功能

1.1 int
1.2 布尔类型

2.有公共功能

2.1 相加

1. 字符串

字符串 + 字符串

2. 列表（list）

两个列表相加获取生成一个新的列表。

3. 元组（tuple）

两个列表相加获取生成一个新的列表。

2.2 相乘：

1. 字符串

字符串 * 整数

2. 列表（list）

列表*整型将列表中的元素再创建N份并生成一个新的列表。

3. 元组（tuple）

列表*整型将列表中的元素再创建N份并生成一个新的列表。

3. 长度

1. 字符串

value = len(data)

2. 列表（list）

print( len(user_list) )

3. 元组（tuple）

print( len(user_list) )

4. 集合（set）

data = len(v)

4. 获取字符串中的字符，索引

1. 字符串

message = "来做点py交易呀"
#          0 1 2345 6 7
#           ... -3 -2 -1
print(message[0]) # "来"

# 注意：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

2. 列表（list）

读

print( user_list[0] )

改

user_list[0] = "武沛齐"

删

del user_list[1] #只能删除，但是拿不到这个值
user_list.remove("刘华强") #也是删除
ele = user_list.pop(1) #不光可以删除还可以拿到这个值

注意：超出索引范围会报错。
提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行读、改、删

3. 元组（tuple）

print( user_list[0] )

4. 字典（dict)

字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。
print( info["name"] ) # 输出：武沛齐

5. 获取字符串中的子序列，切片

1. 字符串

print(message[0:2]) # "来做" 前取后不取

注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想要修改只能重新创建】

2. 列表（list）

多个元素的操作（很少用）

读

print( user_list[0:2] ) # ["范德彪","刘华强"]

改-- 批量改

user_list[0:2] = [11, 22, 33, 44]

删

del user_list[1:]

3. 元组（tuple）

print( user_list[0:2] )

6. 步长，跳着去字符串的内容

1. 字符串

name = "生活不是电影，生活比电影苦"

print( name[ 0:5:2 ] )   # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】

2. 列表（list）

print( user_list[0::2] )

3. 元组（tuple）

print( user_list[0::2] )

7. 循环

1. 字符串

2. 列表（list）

切记，循环的过程中对数据进行删除会踩坑【面试题】。

3. 元组（tuple）

目前：只有 str、list、tuple 可以被for循环。

# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):
    item = user_list[index]
    print(item)

4. 集合（set）

5. 字典（dict)

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

8. 运算符in包含

1. 列表（list）

由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

result = "alex" in user_list

注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

2. 字典（dict)

v1 = "age" in info

9. 减，计算差集

1. 集合（set）

s3 = s1 - s2

10. &，计算交集

1. 集合（set）

s3 = s1 & s2

11. |，计算并集

1. 集合（set）

s3 = s1 | s2

2. 字典（dict)

v3 = v1 | v2

12. 根据键修改值和添加值和删除键值对

1. 字典（dict)

上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作
1. 添加和修改
info["gender"] = "男"

2. 删除键值对

del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错）

2.3 转换

1. int

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0

# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）

# 浮点型（小数）
v1 = int(8.7) # 8

2. 布尔类型

整数0、空字符串、空列表、空元组、空字典、空集合转换为布尔值时均为False 其他均为True

v1 = bool(0)
v2 = bool(-10)

3. 字符串

data = str(num)
一般情况下，只有整型转字符串才有意义。

4. 列表（list）

int、bool无法转换成列表
str
data = list(name) # ["武","沛","齐"]
元祖
v1 = (11,22,33,44) # 元组
vv1 = list(v1) # 列表 [11,22,33,44]
集合
v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]

5. 元组（tuple）

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组。

data = tuple(其他)

6. 集合（set）

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：int/list/tuple/dict都可以转换为集合
提示：这其实也是去重的一个手段。

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}

7. 字典（dict)

想要转换为字典

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

2.4 其他

1. int

1 长整型

Python3：整型（无限制）
Python2：整型、长整形

在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

2 地板除

Py3：
```
v1 = 9/2 
print(v1) # 4.5
```

py2:

v1 = 9/2 
print(v1) # 4

from __future__ import division 

v1 = 9/2 
print(v1) # 4.5

2 布尔类型

如果在 if 、while 条件后面写一个值当做条件时，他会默认转换为布尔类型，然后再做条件判断。

if 值:
  pass

while 值:
  pass

3 字符串

字符串不可被修改
name[1:2]#字符串只能读

4. 嵌套

4.1 列表（list）

列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套
对于嵌套的值，可以根据之前学习的索引知识点来进行学习
data[-2][1] = "alex"

4.1 元组（tuple）

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。

5. 集合（set）

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

6. 字典（dict)

字典的键必须可哈希（list/set/dict不可哈希）。
字典的值可以是任意类型。
字典的键和集合的元素在遇到布尔值和 1、0 时，需注意重复的情况。
元组的元素不可以被替换。

对比

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	`v=[]或v=list()`
tuple	否	是	无	是	tuple(其他)	`v=()或v=tuple()`
set	是	否	可哈希	否	set(其他)	`v=set()`

posted on 2022-10-01 15:30 布丁家的苏苏阅读(25) 评论(0) 收藏举报

刷新页面返回顶部

类型比较

1. 定义

1. int 整形

2. 布尔类型 bool

3. 字符串 str

4. 列表 list

5. 元祖 tuple

6. 集合 set

7. dict 字典

8. float 浮点

2. 独有功能

2.1 int

2.2 布尔类型

2.3 字符串

2.4 列表（list）

2.5 元组（tuple）

2.6 集合（set）

2.7 字典（dict)

3.共有功能

1.无公共功能

2.有公共功能

2.1 相加

1. 字符串

2. 列表（list）

3. 元组（tuple）

2.2 相乘：

1. 字符串

2. 列表（list）

3. 元组（tuple）

3. 长度

1. 字符串

2. 列表（list）

3. 元组（tuple）

4. 集合（set）

4. 获取字符串中的字符，索引

1. 字符串

2. 列表（list）

读

改

删

3. 元组（tuple）

4. 字典（dict)

5. 获取字符串中的子序列，切片

1. 字符串

2. 列表（list）

读

改-- 批量改

删

3. 元组（tuple）

6. 步长，跳着去字符串的内容

1. 字符串

2. 列表（list）

3. 元组（tuple）

7. 循环

1. 字符串

2. 列表（list）

3. 元组（tuple）

4. 集合（set）

5. 字典（dict)

8. 运算符in包含

1. 列表（list）

2. 字典（dict)

9. 减，计算差集

1. 集合（set）

10. &，计算交集

1. 集合（set）

11. |，计算并集

1. 集合（set）

2. 字典（dict)

12. 根据键 修改值 和 添加值 和 删除键值对

1. 字典（dict)

2.3 转换

1. int

2. 布尔类型

3. 字符串

4. 列表（list）

5. 元组（tuple）

6. 集合（set）

7. 字典（dict)

2.4 其他

12. 根据键修改值和添加值和删除键值对