文章目录
基础数据类型
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 |