Python数据类型

一、整形

整形就是十进制整数的统称

1、定义

number = 10
age = 99

2、独有功能

# bit_length 查看整形的二进制由多少个位组成
v1=5
result = v1.bit_length()
print(result)  # 3

3、公共功能

加减乘除，取余，地板除

4、转换

# 布尔值转整形
n1 = int(True)   #1

# 字符串转整形
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

5、 长整形

• Python3：整型（无限制）

• Python2：整型、长整形

• int，可表示的范围：-9223372036854775808～9223372036854775807

• long，整数值超出int范围之后自动会转换为long类型（无限制）。

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

二、布尔类型

1、定义

data = False
is_login = True

2、转换

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

2、1 做条件自动转换

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

三、字符串类型

1、定义

v1 = "包治百病"
v2 = '包治百病'
v3 = "包'治百病"
v4 = '包"治百病'
v5 = """
吵架都是我的错，
因为大家打不过。
"""
# 三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。

2、独有功能

"xxxxx".功能(...)
v1 = "xxxxx"
v1.功能(...)

v1="dddd|ddxxx"
data_list = ["dean","charles","yes"]

v1.startswith("dd")     # 判断是否以dd开头
v1.startswith("xx")     # 判断是否以xx结尾
v1.isdecimal("dd")     # 判断是否为十进制数
v1.isdigit("dd")     # 判断是否为整数
v1.strip()     # 去除字符串两边的空格、换行符和制表符
v1.lstrip()     # 去除字符串左边的空格、换行符和制表符
v1.rstrip()     # 去除字符串右边的空格、换行符和制表符
v1.strip("/")     # 去除字符串两边的指定字符
v1.lstrip("/")     # 去除字符串左边的指定字符
v1.rstrip("/")     # 去除字符串右边的指定字符
v1.upper()		# 字符串变大写
v1.lower()		# 字符串变小写
v1.replace("原字符串","新字符串")  # 字符串内容替换
v1.split("|")   # 以指定字符分割字符串，得到一个列表
v1.split("|",2)   # 从左以指定字符分割字符串2次，得到一个列表
v1.rsplit("|",1)   # 从右以指定字符分割字符串1次，得到一个列表
"-".join(data_list) # 用-将列表中的字符串进行拼接
"{}雨下的很大{}".format{"今天","啊"}   # 字符串格式化
"%s雨下的很大%s" % ("今天","啊")       # 字符串格式化
v1.encode("utf-8") 		# 字符串编码为字节类型
v1.center(50,"-")		# 共50个字符，v1居中显示，其余使用-进行填充
v1.ljust(50,"-")		# 共50个字符，v1居左显示，其余使用-进行填充
v1.rjust(50,"-")		# 共50个字符，v1居右显示，其余使用-进行填充
v1.zfill(10)			# 在v1字符串前填充0，将字符串长度变为10

3、公共功能

3、1 相加

"a"+"b"-->"ab"

3、2 相乘

"a" * 3 --> "aaa"

3、3 长度

len("abc")  # 3

3、4 索引

message = "来玩啊，今天天气真好"

print(message[2]) # 啊
print(message[-1]) # 好

3、5 切片

message = "来玩啊，今天天气真好"

print(message[0:2]) # 来玩啊
print(message[4:-1]) # 今天天气真好
print(message[0:4:2]) # 来啊   （步长2）

3、6 转换

num = 999
data = str (num)  #"999"

四、列表类型

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

1、定义

user_list =  ["老师","有坂","大桥"]
number_list = [98,88,666,12,-1]
data_list = [1,True,"Alex","宝强","贾乃亮"]

user_list = []
user_list.append("铁锤")
user_list.append(123)
user_list.append(True)
print(user_list) # ["铁锤",123,True]

不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）

可变类型：列表（内部数据元素可以修改）

2、 独有功能

data_list = ["may","june"]

data_list.append("dean")   # 追加
data_list.extend([1,2,3])  # 扩展，将另一个列表中的元素逐一追加到原列表中
data_list.insert(2,"sam")  # 插入，在原列表指定索引位置插入值
data_list.remove("may")    # 在原列表中从左到右根据值删除，只删除找到的第一个（慎用，找不到会报错）
data_list.pop(0)	       # 在原列表中根据索引删除，不指定索引默认删除最后一个，返回值为删除的值
data_list.clear()		   # 清空列表
data_list.index("may")	   # 从左到右找到第一个删除，并返回该值的索引（慎用，找不到报错）
num_list.sort()			   # 数字排序，从小到大排序，字符串排序按照ASCII码排序比较，列表内数据类型不统一							  时会报错
num_list.sort(reverse=True)# 数字排序，从大到小排序
data_list.reverse()		   # 反转原列表

3、公共功能

["赵四","刘能"] + ["宋晓峰","范德彪"]    # 相加得到新列表
["赵四","刘能"] * 2	--> ["赵四","刘能","赵四","刘能"] # 将列表中的元素再复制N份生成一个新列表
# 运算符in ,判断元素是否在列表中（列表检查元素是否存在时，采用逐一比较的方式，效率比较低）
# len()  获取长度
data_list[0]     # 按索引取值，修改(超出索引范围会报错)
del data_list[1] # 相当于data_list.pop(1)

# 切片（可读，可改，可删）
    user_list[0:2]   
    user_list[1:] 
    user_list[:-1] 
    
# 步长
	user_list[1:4:2]
    new_data = user_list[::-1] # 列表反转
    
# 循环中删除列表元素的正确方式（倒着循环，删除后不影响剩余元素的索引）
    user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
    for index in range(len(user_list) - 1, -1, -1):
        item = user_list[index]
        if item.startswith("刘"):
            user_list.remove(item)
    print(user_list)

4、转换

• int、bool无法转换为列表
• str

name = 'sam'
list(name)   # ['s','a','m']

• 元组、集合

v1 = (11,22,33,44) # 元组
vv1 = list(v1)     # 列表 [11,22,33,44]

v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]

5、嵌套

列表内可以存放各种数据，可以嵌套列表、字典、集合等数据类型

五、元组类型

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

1、定义

v1 = (11,22,33)
v2 = ("刘能","dean")
v3 = (True,123,"dean",[11,22,33,44])  # 元组内的可变类型中的元素可以修改

# 建议：议在元组的最后多加一个逗v3 = ("刘能","dean",)
d1 = (1)  # 1    内部处理成1
d2 = (1,) # (1,)

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

2、功能

相加、相乘，获取长度、索引、切片、步长同列表

索引、切片、步长生成的是新的数据

循环同列表

3、 转换

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

六、集合类型

集合是一个 无序 、可变、不允许数据重复的容器，元素必须可哈希（集合的元素只能是 int、bool、str、tuple ）

1、定义

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

• 无序，无法通过索引取值
• 可变，可以添加和删除元素
• 不允许数据重复

v1 = {11,22,33,44}
v1.add(55)
print(v1) # {11,22,33,44,55}

一般什么时候用集合呢？

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

注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

v1 = []
v11 = list()

v2 = ()
v22 = tuple()

v3 = set()

v4 = {} # 空字典
v44 = dict()

2、功能

data = {"刘嘉玲", '关之琳', "王祖贤"}
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

data.add("郑裕玲")     #  添加元素
data.discard("关之琳") # 删除元素
s4 = s1.intersection(s2) # 取两个集合的交集 
s3 = s1 & s2   			  # 取两个集合的交集
s4 = s1.union(s2) 		# 取两个集合的并集  {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
s3 = s1 | s2   			# 取两个集合的并集
s4 = s1.difference(s2) 		# 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1)   	# 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}
s3 = s1 - s2   			   # 差集，s1中有且s2中没有的值
s5 = s2 - s1   			   # 差集，s2中有且s1中没有的值
len(data)					# 长度
for循环遍历集合中的值

3、转换

int/list/tuple/dict都可以转换为集合,主要用于去重

v1 = "dean"

v2 = set(v1)

4、特点

因存储原理特殊，集合的查找效率非常高

5、对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=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}

七、None类型

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是 或 表示空。 相当于其他语言中 null

在一定程度上可以帮助我们去节省内存。

八、字典类型

字典是 无序、键不重复 且 元素只能是键值对的可变的 个 容器。（字典的查找速度快）

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

• 容器

• 元素必须键值对

• 键不重复，重复则会被覆盖

• 无序（在Python3.6+字典就是有序了，之前的字典都是无序。使用ordereddict有序字典）

字典中对键值的要求：

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

1、独有功能

写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。

info = { 
    "age":12, 
    "status":True, 
    "name":"dean",
    "data":None
}
info.get("name")		# 获取值，键不存在默认返回None，可在第二个参数指定默认返回的值
info["name"]			# 获取值，键不存在时报错
info.keys()				# 获取字典所有的键，注意：在Python2中 字典.keys()直接获取到的是列表，而							  Python3中返回的是`迭代器`
info.values()			# 所有的值
info.items()			# 所有的键值对，每个键值对返回一个元组
info.setdefault("age",18) # 字典中不存在该键时，添加该键值对，存在该键时，不进行任何操作
info.update({"age":18,"name":"sam"})	# info中没有的键直接添加；有的键则更新值
info.pop("name")		# 移除指定键值对，不存在返回None
info.popitem()			# py3.6后，popitem移除最后的值,py3.6之前，popitem随机删除

2、公共功能

1、求并集（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}

2、长度

len(info)

3、是否包含

in,默认判断是否在键中

4、根据键 修改值 和 添加值 和 删除键值对

info["gender"] = "男" # 添加和修改值
del info["age"]   # 删除，键不存在报错

5、for循环

for item in info:
    ...
for item in info.values():
    ...
for key,value in info.items():
    ...

3、转换

# 其他类型转换为字典
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

# 字典转换为列表
info = { "age":12, "status":True, "name":"dean" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"dean"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","dean") ]

九、浮点型（float)

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

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

• 在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。

  v1 = 3.14 
  data = int(v1)
  print(data) # 3
  

• 想要保留小数点后N位

  v1 = 3.1415926
  result = round(v1,3)
  print(result) # 3.142
  

• 浮点型的坑（所有语言中）

v1=0.1
v2=0.2

v3 = v1 + v2
print(v3)    # 0.300000000000000004

在项目中如果遇到精确的小数计算应该使用decimal

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3