Python学习 之 基础数据类型

---

基础数据类型

int - 整形

""" 
	默认用十进制表示

"""

""" 计算 """
# + 加
5+1 # 6

# - 减
5-1 # 4

# * 乘
5*1 # 5

# / 除
5/1 # 5

# // 地板除(取整)
5//2 # 2

# % 取余
5%2 # 1

# divmod 商余
divmod(5, 2) # (2, 1)

# ** 乘方
5**2 # 25

""" 转换 """
# 十进制 转 二进制
bin(10) # 0b1010

# 十进制 转 八进制
oct(10) # 0o12

# 十进制 转 十六进制
hex(10) # 0xa

""" 求长度 """
# 十进制数字转化成二进制数字最少需要几位
a = 10
a.bit_length() # 4

---

float - 浮点

• python中, 浮点数就是数学中的小数
• 在运算中, 整数与浮点数运算的结果也是一个浮点数
• 小数不精准是因为在转换成二进制的过程中会出现无限循环的情况, 约省出现偏差

---

str - 字符串

"""
	python中, 引号内的, 有序的, 字符的集合称为字符串, 索引从0开始
	适合储存简单的少量的数据
	
"""

s = "abcdefg"

# 索引取值, 返回单个元素
s[0] # a

# 切片取值, 返回 str
s[0:2] # "ab", 索引左闭右开
s[-3:-1] # "ef", 支持负数索引, 同样左闭右开
s[:] # 允许索引为空, 表示从起始位开始, 或到末尾结束

# 切片加步长
s[::2] # 步长为 2, 从起始位开始, 向后取值, "aceg"
s[-1::-1] # 步长为 -1, 从索引 -1 开始, 向前取值, gfedcba

---

bool - True or False

# False
None
0 --> 数字0
'' --> 空字符串
() --> 空集合
[] --> 空列表
{} --> 空字典


# True
其余都为真

---

list - 列表

"""
	中括号内的元素的集合
	有序
	可变
	切片取值类型为 list

"""

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

# 索引取值, 返回单个元素
l[0] # 1

# 切片取值, 返回 list
l[0:2] # [1, 2], 索引左闭右开
l[-3:-1] # [3, 4], 支持负数索引, 同样左闭右开
l[:] # 允许索引为空, 表示从起始位开始, 或到末尾结束

# 切片加步长
l[::2] # 步长为 2, 从起始位开始, 向后取值
l[-1::-1] # 步长为 -1, 从索引 -1 开始, 向前取值

---

tuple - 元组

"""
	只读列表(不可变)
	有序
	切片取值类型为 tuple

"""

t = (1, 2, 3, 4, 5)

# 索引取值, 返回单个元素
l[0] # 1

# 切片取值, 返回 tuple
l[0:2] # (1, 2), 索引左闭右开
l[-3:-1] # (3, 4), 支持负数索引, 同样左闭右开
l[:] # 允许索引为空, 表示从起始位开始, 或到末尾结束

# 切片加步长
l[::2] # 步长为 2, 从起始位开始, 向后取值
l[-1::-1] # 步长为 -1, 从索引 -1 开始, 向前取值

---

dict - 字典

"""
	大括号内的有对应关系的键值对的集合
	key: 唯一, 且必须是不可变(可哈希)的数据类型. 如: str, bool, tuple, int.
	valu: 可以是任意类型
	存储数据多, 关系型数据, 查询速度快(二分查找)
	python3.6版本前dict是无序的, 之后是有序的
	
"""

d = {"a": 1, "b": 2, "c": 3}

# 根据 key 取值
print(d["a"]) # 1

# for 循环取值
for k in d:      # k 取出的是字典中的 key
    print(d[k])  # 根据 key 取 value

# for 循环 + dict.items() 取值
for k,v in d.items():
    print(k,v) 
    

---

set - 集合

"""
	无序, 不重复的数据类型
	里边的元素必须是不可变(可哈希)的
	但集合本身是可变(不可哈希)的

"""

# 以下都使用这两个集合
set1 = {1,2,3}
set2 = {2,3,4}

# 交集
set1 & set2 # 结果为{2,3}

# 并集
set1 | set2 # 结果为{1,2,3,4}

#差集
set1 - set2 # 结果为{1}
set2 - set1 # 结果为{4}

# 反交集
set1 ^ set2 # 结果为{1,4}

# 子集
set1 < set2 # 结果为false

# 超集
set1 > set2 # 结果为 False

---

要点补充

• 在循环 list 或 dict 的同时, 不要改变它的大小
• 如果 tuple 内只有一个元素, 并且没有用逗号分隔, 则它的数据类型和该元素原数据一致
• “is” 和 “==” 的却别
  • is 比内存地址
  • == 比数值
• 小数池, 是指int类型, -5 ~ 256 范围内使用同一个内存地址

---

使用实例

使用实例 - 列表去重

""" 先将列表转换成集合, 利用集合元素唯一的特性去重, 再将它转回列表 """

li = [1,2,2,3,3,3]
list(set(li)

# 结果为 [1,2,3]

---

深浅copy

import copy

# 常用的赋值
a = [1,2,3,4,5]
b = a
print(a is b) # True, a b 指向的是同一快内存空间, 


# copy
a = [1,2,3,[4,5]]
c = copy.copy(a)
print(a is c) 					# False
print(a[-1] is c[-1]) 			# True
c[-1] = [10,20] 				# 变更 c[-1] 的值
print(a[-1] is c[-1])			# False, 变更后新建了内存空间存放新的值


# deepcopy
a = [1,2,3,[4,5]]
d = copy.deepcopy(a)
print(a is d)					# False
print(a[-1] is d[-1])			# False
d[-1] = [10,20]					# 变更 d[-1] 的值, 因为内存空间引用不同, 所以不会影响原数据
print(a[-1] is d[-1])			# False

---

常用方法表

数据类型使用方法表

方法名	效果	备注
字符串(str)	-	-
-	处理字符串	-
str.capitalize()	字符串的第一个字符若是字母, 则大写	“abc” -> “Abc” “1abc” -> “1abc”
str.title()	非字母分隔的单词,首字母大写	“ab ac” -> “Ab Ac” “1ab 1ac” -> “1Ab 1Ac”
str.upper() str.lower() str.swapcase()	全大写 全小写 大小写反转	“aBc” -> “ABC” “aBc” -> “abc” “aBc” -> “AbC”
str.center(len, “sep”)	总长度 len , str居中, 其他位置用 sep 补充	“abc” -> “-abc-”
str.startswith(“sep”) str.endswith(“sep”)	判断 str 是否为 sep 开头 判断 str 是否为 sep 结尾	返回值为bool
str.strip(“seps”) str.lstrip(“seps”) str.rstrip(“seps”)	去除 str 首尾包含的 seps 中元素 去除 str 开头包含的 seps 中元素 去除 str 结尾 包含的seps 中元素	默认参数为空格
str.split(“sep”)	以 sep 作为分割, sub默认为空格	返回值类型为list, 若首位为sep, 则list[0]为""(空字符串)
“sep”.join(str)	以 sep 连接 str 中每一个元素
str.replace(old_str, new_str, count)	用 new_str 替换 old_str , 替换数量为 count , 默认范围为整个 str
str.find(s)(推荐使用) str.index(s)	返回 str 中第一次出现 s 的索引	找不到则返回 -1 找不到则报错
str.isalnum() str.isalpha() str.isdigit()	判断str是否为数字和字母 判断str是否全为字母 判断str是否全为数字
-	其他	-
len(str)	获取字符串长度
str.count(s)	获取str中s的出现次数	返回值是个 int, 未找到返回 0
format	格式化字符串	1.‘我叫{}, 今年{}岁, 他叫是{}’.format(‘Tim’,‘15’,‘Tom’) 2.‘我叫{0}, 今年{1}岁, 他也叫{0}’.format(‘Tim’,‘15’) 3.‘我叫{name}, 今年{age}岁, 爱好是{hobby}’.format(age=‘15’,hobby=‘eat’,name=‘Tim’)
列表(list)	-	执行后均会直接改变 list
-	增加	-
l.append(sub)	在 l 最后增加 sub
l.insert(index, sub)	在 l[index] 位置添加 sub, 后边的元素后移
l.extend(iterable)	将可迭代对象, 通过迭代, 依次添加到 l 中	合并两个列表的所有元素
-	删除	-
l.pop(index)	根据索引删除元素	有返回值, 返回值为删除的元素
l.remove(sub)	根据元素删除(只删除第一个出现的)
l.clear()	清空列表
del l del l[index] del l[start_pos: end_pos] del l[start_pos: end_pos, step]	删除 l 使用 l[index] 元素 使用切片删除 l 中元素 使用"切片+步长"删除 l 中元素	内存级别的删除
-	修改	-
l[index] = sub	将 l[index] 的元素赋值为 sub
l[start_pos, end_pos] = iterable	先删除 l 切片范围元素, 再将可迭代对象, 迭代添加进列表
l.reverse()	将 l 内元素反向排序
-	查询	-
l[index]	按照索引查询元素
l.index(sub)	根据元素返回索引(第一个出现位置的索引)
-	其他	-
len(l)	获取字符串长度
l.count(sub)	获取 li 中 sub 的出现次数
l.sort()	将 li 内元素按从小到大排序 若设置参数 reverse = True , 则从大到小排序
元祖(tuple)	-	-
tuple.index(sub)	通过 sub 找索引
tuple.count(sub)	查找 sub 出现的次数
len(tuple)	返回元组的长度
字典(dict)	-	-
-	增加 & 修改	-
dict[key] = value	key 若存在则修改对应的value key 若不存在则添加该 k,v
dict.setdefault(key:value)	key 若存在则不变 key 若不存在则添加该 k,v
dict2.update(dict1)	将 dic1 的 k,v 覆盖到 dic2 中	重复 kv 则替换, 不存在的则添加
-	删除	-
dict.pop(key)	删除 dict 中为 key 对应的 k,v, 并返回 v	增删改中唯一一个有返回值的方法
dict.clear()	清空dict
del dict	内存级别的删除 dict
-	查	-
dict.get(key, tips)	获取 key 对应的 value , 若找不到则返回 tips
dict.keys()	返回值为 dict_keys([k1,k2,k3…]), 类型为 dict_keys
dict.values()	返回值为 dict_values([v1,v2,v3…]), 类型为 dict_values
dict.items()	返回值为 dict_items([(k1,v1),(k2,v2),(k3,v3)…]), 类型为 dict_items
-	其他	-
len(dict)	返回 dict 中键值对的个数
dict.fromkeys(iterable, v)	将可迭代数据通过迭代依次作为 key, 值对应 v 添加进 dict	有返回值, 不会改变原字典
集合(set)
-	增加	-
set.add(sep)	添加sep
set.update(iterable)	将可迭代数据 args ,通过迭代依次添加进 set
-	删除	-
set.remove(sep)	删除 sep
set.pop()	随机删除
set.clear()	清空 set
del set	内存级别删除 set
-	其他	-
forzenset(set)	将 set 转换为 frozenset 类型	该类型为不可操作的 set 类型

---

数据类型转换方发表

数据类型转换	方法	备注
整型 --> 别的数据类型
int --> str	str(int)
int --> bool	bool(int)	0为False, 非0位True
字符串 --> other
str --> int	int(str)	str中元素为数字
str --> bool	bool(str)	‘’(空字符串)为False, 非空为True
布尔值 --> other
bool --> int	int(bool)	True转换为1, False转换为0
列表 --> other
元组 --> other
字典 --> other