python数据类型

目录

• str
  • str的方法
  • 切片索引步长
• bool
• int
  • 进制转换
  • bit_length()
• list
  • 创建列表
  • list增删改查
  • list切片 索引步长
  • 列表的嵌套:
  • 其他方法
• tuple
  • 元组的嵌套
  • 其他方法
  • 拆包
• 字典dict
  • 字典的创建方式
  • 增删改查
  • 字典的嵌套
  • 补充方法与枚举
• 集合
  • 集合的创建
  • 增删改查

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)