目录
str
1.字符串 -- 用于存储数据的 -- 比较少
2.python 中只要是用引号 引起来的就是字符串
3.支持索引（引取值的时候超出了索引的范围会报错），切片（切片如果终止位置超出了不报错），步长
注意事项
list('1234')#['1', '2', '3', '4']
str的方法
字符串方法 其实就是调用类的方法 字符串是数字不会报错
b=' aBdsfdfhgjkc6'
1.大小写转化
print(b.upper())# 全部大写
print(b.lower())# 全部小写
2.判断开头结尾
print(b.startswith('a')) # 以什么开头
print(b.endswith("c"))# 以什么结尾
3.计数
# print(b.count("zhu")) # 查询某个内容出现的次数
4.替换
# b1 = b.replace('n','s',2) # 替换 2是替换的次数 第一个参数旧的 第2个新的
5.去空格
# b2 = b.strip('6') #返回移除字符串头尾指定的字符生成的新字符串 （只要头尾包含有指定字符序列中的字符就删除：） 默认去空格
6.切割
str.split(第1个参数,第2个参数) 返回列表
第1个参数 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
第2个参数 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
7.判断数据形式
print(name.isdecimal()) # 判断是不是十进制 -- 用它来判断是不是数字
print(name.isalpha()) # 判断的是中文和字母
print(name.isalnum()) # 判断的是不是字母，中文和阿拉伯数字
9.字母大写相关
首字母大写 capitalize()
s1 = object.capitalize()
每个单词首字母大写 title()
s = "alex wusir"
s1 = s.title()
大小写转换 swapcase()
print(s.swapcase())
10.查找相关
利用元素找索引 find()
print(s.find("c")) # find 查找不到的时候返回 -1
print(s.index("C")) # index 查找不到就报错
切片索引步长
特点
1.从左向右数 0,1,2,3
2.从右向左数 -1，-2，-3，-4
3.顾头不顾尾
列题
a='123456789'
print(a[::3])#147
print(a[1:3])#23
print(a[0],a[-1])#1 9
bool
bool # 布尔值 -- 用于条件判断使用 两种形式
True 真
False 假
print(bool(0))
True 转化成数字 1 False 转换成数字 0
非0 非空(空字符串，空列表，空元祖，空集合，空字典) 就是True
print((str(True)))#true
print(type(str(True)))#str 布尔值可以转换成字符串
int
1.不可变数据类型，int可以进行4则运算
算数运算 +， - ，* ，/ ，%， **幂，//取整 %取余
2.十进制二进制转换 列如42----0010 1010
进制转换
bit_length()
python给咱们提供了一种方法：bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.
num = 10
print(num.bit_length()) # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4
list
1.可变数据类型，是一个容器，任意类型都可以放到容器中
2.有序的的数据类型，支持切片,步长
3.可以在本身上进行修改 可以增加 - 删除 - 修改
补充
# 列表不能用insert
#效率低了一个变后面都会变 补位
# 列表不能用pop(n)
##效率低了一个变后面都会变 补位
创建列表
创建列表3种方式 （列表推导式，自己创建）
1.第1种
# l1 = [1,2,3,'123',True,[1,2,5]]
2.第2种
# l1=[i for i in range(9)]
3.第3种
l1 = list() # 空列表
#l1 = list(iterable) # 可迭代对象
l1 = list('123')
print(l1) # ['1', '2', '3']
list增删改查
l1 = [1,2,3,'alex',3,[1,2,3]]
#增加
l1.append('sq') #追加 添加在末尾 添加的操作
l1.insert(0,"mcsq") #插入 第一个参数(索引),第二参数要插入的内容
l1.extend("abc") # 扩展 -- 迭代添加 -- for
l2 = ["a","b","c"]+[1,2,3]# 列表合并["a","b","c",1,2,3]
l3=[[]]*3#[[], [], []]列表相乘
# 删
# l1.remove(1) # 删除 按照元素名进行删除
# print(li.pop(索引))
# 弹 pop有返回值 返回的是被删除的内容# 默认删除的是最后一个# 可以通过索引指定删除
del l2#将整个容器都删掉了
# del l2[2] #del 支持索引删除
# del l2[0:3] #del 支持切片删除
# del l2[::2] # del 支持步长删除
# 清空
# li.clear() # 清空里面元素 列表还在
# 索引改
# li = [0,1,2,3,4,5]
# # li[0:2] = [] # [2, 3, 4, 5] # 没有步长迭代进去的 可以多,可以少
# li[::2]=[1,2,3]#有步长，不可以多，不可以少 否则报错
# print(li)
list切片 索引步长
与字符串相似
列表的嵌套:
# 抽丝剥茧
其他方法
补充方法
list
l1=[1,2,3,4,5,6,6,5,4,3,2,1]
list:
计数count()
print(li.count("1"))
利用元素找索引 find()
print(li.index("C")) # index 查找不到就报错
反转 reverse()原列表反转
l1.reverse()
排序 原列表升序或降序
li.sort() # 升序
li.sort(reverse=True)
tuple
1.元组不可变数据类型，如果元组中还包含其他可变元素，这些可变元素可以改变
2.只有当元组内的所有元素都为不可变类型的时候，才能成为字典的key
3.小括号中一个元素的时候没有逗号就括号中元素的本身
4.小括号中一个元素的时候有个逗号就是元组
5.空的小括号就是元组
6.元组有序可以索引,切片,步长
7.元祖不可以增删改 可以 索引 切片
为什么要有元祖？
保护数据安全
元组的嵌套
其他方法
tuple
tu=(1,2,3)
tuple:
计数
print(tu.count("3"))
利用元素找索引 index()
print(tu.index("1"))
拆包
# 拆包
# a = 1
# b = 2
# a,b = b,a
# print(a,b)
字典dict
1.可变数据类型，是一个容器 键值对形式的存储方式
2.必须是可哈希(不可变的数据类型),并且是唯一的 # 值: 任意
3.字典比较消耗内存 查询速度快
4.可以增删改查
# 字典的无序的,python3.6版本以上 默认了咱们定义顺序,python3.5以下是随机显示
字典的创建方式
# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式5: 后面会讲到先了解
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)
# 方式6: 字典推导式 后面会讲到
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
# 方式7:利用fromkey后面会讲到。
# dic = dict.fromkeys('abcd','太白')
# print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
第一个参数可迭代对象
第二个参数是每个键对应的值 -- 用的都是同一个内存地址
增删改查
dic = {"a":"b","b":"c"}
增:
# dic.setdefault("key","values")#存在就不添加,不存在就添加
# dic["s"] = "ssss" # dic[键] = 值
删:
# print(dic.pop("a")) #通过键删除 pop具有返回值,返回的被删除的值
# del dic["b"] #删除指定的键值对
# del dic # 删除整个字典
# dic.clear() # 清空字典元素
改:
# dic["b"] = "这是值" # 键在字典中存在就是修改,键在字典中不存在就是增加
# dic.update({6:6}) # update括号里的字典级别高有更新覆盖 无则添加
查:
# 字典的查询只能通过键获取值,不能通过值获取键
# print(dic["c"]) 键不存在的时候不报错
# print(dic.get("c","不存在"))# 键存在返回值,键不存在设定第2参数的时候不报错
# dic = {1:2,"a":"a1"}
# for i in dic: # for循环字典的时候打印的是字典的键
# print(i,dic[i])
# for k,v in dic.items():
# print(i)
字典的嵌套
# 字典的嵌套:
补充方法与枚举
# 枚举 默认从0开始
# enumerate()
list = ['a','b', 3, 4, 5, 6]
for i, j in enumerate(list):
print(i+1,j)
dic.popitem() #随机删除
python3.6版本 默认删除最后个键值对
python3.5版本以前 随机删除
集合
1.可变数据类型 是一个容器
2.集合是无序的，值是唯一的，可哈希的
3.集合里面有元祖，只有当元组内的所有元素都为不可变类型的时候才可以做集合元素
集合的创建
# 创建set
# s = set("1234") # 定义方式
s={1,2,3,"123",False,(1,2,3,4,)}
print(s,type(s))
增删改查
# 增:
# s.update("3456") # 迭代添加
# s.add("怼怼")
#删:
# s.pop() #随机删除
# s.clear() # 清空
# del s #删除整个集合
# 改:
# 删了,在加
# 查:
# for
# 天然去重 -- 唯一 列表去重
# print(s1 - s2) #差集
# print(s1 | s2) #并集 (合集)
# print(s1 & s2) #交集
# print(s1 ^ s2) #对称差集 -- 反交集
# print(s1 > s2) # 超集 -- 父集
# print(s1 < s2) # 子集
# 冻结集合(可变 转换成 不可变) -- 更不常用
# f_s = frozenset({1,2,3,4,5})
# dic = {f_s:"1"}
# print(dic)