python数据类型

数值类型
1.1 整型int
- 类型转换：int("10")
- 10进制转为二进制：bin()
- 10进制转为八进制：oct()
- 10进制转为16进制：hex()
- 二进制转为10进制：int("0b1011",2)
- 八进制转为10进制：int("0o13",8)
- 16进制转为10进制：int('0xb',16)
1.2 浮点型float:使用同int
字符串类型
2.1 用引号（''，""，''' '''，""" """，）包含的一串字符
2.2 类型str
2.3 类型转换：str(xxx)，可以将任意类型转为字符串
2.4 内置方法：
- 按索引取值(正向取+反向取) ：只能取
```
msg='hello world'
# 正向取
print(msg[0])
print(msg[5])
# 反向取
print(msg[-1])
```
- 切片[start:end:step]:索引的拓展应用，从一个大字符串中拷贝出一个子字符串
```
msg='hello world'
# 步长
print(msg[0:5:2]) # hlo

# 反向步长
print(msg[5:0:-2]) # " le"
```
- 默认切片：[:]、[::-1](字符串倒序)
- 长度：len()
- 成员运算in和not in
- 移除字符串左右两侧的符号：strip()，产生新值
  - 默认str.strip()是去掉左右空格
  - str.strip("*")去掉左右*,以此类推
  - lstrip():去掉左侧空格
  - rstrip():去掉右边空格
- 切分：split(xxx,分割次数)按照分隔符xxx切分成列表，默认是空格
  - rsplit():从右开始分割
- lower():大写转小写
- upper():小写转大写
- startswith():以xxx开头
- endswith():以xxx结尾
- format():字符串格式化
- join():xx.join(list),将列表list以分隔符xx连接到一起
- replace(目标元素，替换元素，[次数]):替换
- str.isdigit():判断str是否由纯数字组成
```
print('123'.isdigit()) # True
print('12444.3'.isdigit()) # False
```
- find():返回起始索引，找不到返回-1
  - rfind():从右开始查找
- index():返回起始索引，找不到抛出异常
  - rindex():从右开始查找
- count(xxx):返回xxx出现的个数
- 对齐方式
  - str.center(位数，填充参数)：居中对齐，填充
  - str.ljust(位数，填充参数):左对齐，其余填充
  - str.rjust(位数，填充参数):右对齐，其余填充
  - str.zfill(位数):右对齐,填充0
- str.expandtabs(空格数)：设置制表符代表的空格数
```
msg='hello\tworld'
print(msg.expandtabs(12)) # 设置制表符代表的空格数为12
```
- str.capitalize():首字母大写
- str.swapcase():大小写字母切换
- str.title():每个单词首字母大写
- str.isXXX():
```
print('abc'.islower())
print('ABC'.isupper())
print('Hello World'.istitle())
print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
print('ad'.isalpha()) # 字符串由由字母组成结果为True
print('     '.isspace()) # 字符串由空格组成结果为True
print('print'.isidentifier())
print('age_of_egon'.isidentifier())
print('1age_of_egon'.isidentifier()) # 字符是否有效

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

# isdigit只能识别：num1、num2
# print(num1.isdigit()) # True
# print(num2.isdigit()) # True
# print(num3.isdigit()) # False
# print(num4.isdigit()) # False

# isnumberic可以识别：num2、num3、num4
# print(num2.isnumeric()) # True
# print(num3.isnumeric()) # True
# print(num4.isnumeric()) # True

# isdecimal只能识别：num2
# print(num2.isdecimal()) # True
# print(num3.isdecimal()) # False
# print(num4.isdecimal()) # False
```
列表类型
3.1 索引对应值，[]中以逗号隔开任意类型的值，每一个值称为一个元素
3.2 索引反映的是顺序、位置，对值没有描述性的功能
```
nams_list = ['hyf','asd','sdfass',3,{"name":"bbb"}]
```
3.3 类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
3.4 内置方法；
- 按索引存取值(正向存取+反向存取)：即可以取也可以改，索引不存在则报错
- 切片(顾头不顾尾，步长)：list[start:end:step]切片等同于拷贝行为，而且相当于浅copy
- len(list):返回列表长度
- in、not in:成员运算符
- 添加值:
  - list.append():追加
  - list.insert(位置，值):插入
  - list2.extend(list1):将list1做了一层扁平化，然后追加到list2列表中
- 删除：
  - del list[0]:只是删除没有返回值
  - list.pop([index]):默认删除最后一个，可以通过传入的下标删除，超出报错
  - list.remove(目标元素)：根据元素删除，返回None
- list.count(目标元素)：返回目标元素的个数
- list.index(目标元素)：返回目标元素的下标，没找到报错
- list.clear():返回一个空列表
- list.reverse():列表倒序
- list.sort([reverse=True]):默认从小到大排序，reverse=True时从大到小排序
元组：一个不可变的列表
1. 作用：按照索引/位置存放多个值，只用于读不用于改
2. 定义：(value1,value2,....)小括号内用逗号隔开,单独一个括号代表包含的意思,如果元组中只有一个元素，必须加逗号
3. 类型转换：tuple()
```
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple([1,2,3])) # (1, 2, 3)
print(tuple({'a1':111,'a2':333})) # ('a1', 'a2')
```
4. 内置方法：
  - 按索引取值(正向取+反向取)：只能取
  - 切片(顾头不顾尾，步长)
  - len()
  - in、not in:成员运算
  - index():查找元素下标
  - count():获取目标元素在元组中的个数
字典类型
1. 键值对，key对值有描述性的功能
2. {key:value,...}key必须是不可变类型
3. 定义：
  1. d = {'k1'=11,'k2'=33}
  2. d = dict(x=1,y=2,z=3)
  3. d = dict([["name",'hyf'],["age",22]])
  4. 快速初始化
```
keys = ['name','age','gender']

d = {}.fromkeys(keys,None)
```
4. 内置方法：
  - 按key存取值：可存可取
  - len(dict):长度
  - 成员运算in和not in:根据key
  - 删除：
    - del dict[key]
    - dict.pop(key)
    - dict.popitem():随机删除，返回元组(删除的key,删除的value)
  - dict.keys():在python3中返回的是dict_keys,需要使用for循环取值
```
d = {"k1":22,"k2":44}
my_dict_list = d.keys() # dict_keys(['k1', 'k2'])
for k in my_dict_list:
   print(k) # k1,k2
# 可以使用 list函数将dict_keys转化为列表
my_dict_list2 = list(d.keys()) # ['k1', 'k2']
```
  - dict.values():获取value值dict_values,同上
  - dict.items():获取键值对，同上
  - dict.clear():清空
  - dict.update():更新字典，
  - dict.get(key):取值，key不存在时返回None
  - dict.setdefault(key):如果key存在则不添加，否则添加。返回字典中key对应的值
```
info_dict = {"k1":22}
info_dict.setdefault("k1",555)
print(info_dict) # {"k1":22} 因为k1存在
info_dict.setdefault("k2",555)
print(info_dict) # {"k1":22,"k2":555} 因为k2不存在
```
布尔类型:真假状态True 和 False

集合

作用：
1. 关系运算
2. 去重
  1. 只能针对不可变类型
  2. 无法保证原有顺序

定义：在{key1,key2}中用逗号隔开多个元素，

# 1. 集合内元素必须为不可变类型
# 2. 集合内元素无序
# 3. 集合内元素没有重复
s = {1,2,1} # s = set({1,2,1})
print(s,type(s)) # {1, 2} <class 'set'>

# s = {1,[2,3]} # 报错
# s = {1,'a','z','b',4,7} 
# print(s,type(s)) # {1, 'z', 4, 7, 'a', 'b'}  <class 'set'>
# 默认是空字典
# s={} 
# 空集合
# s = set() # print(s,type(s))-->set() <class 'set'>

类型转换：set(可迭代类型)

print(set('hello world')) # {'r', 'o', 'e', 'w', 'd', 'l', ' ', 'h'}
print(set({'key1':2,"key2":3})) # {'key2', 'key1'}
print(set([1,1,1,1,1,1])) # {1}

内置方法

取交集：两者共同部分
取并集：两者全部
取差集：某一方独有
对称差集：两方独有

父子集：包含关系

set1 = {"zero","kevin","jason","egon"}
set2 = {"Jy","ricky","jason","egon"}
# 交集
res_1 = set1 & set2
res_2 = set1.intersection(set2)
print(res_1) # {'egon', 'jason'} {'egon', 'jason'}

# 并集
res_3 = set1|set2
res_4 = set1.union(set2)
print(res_4) # {'zero', 'egon', 'kevin', 'ricky', 'Jy', 'jason'}

# 取差集
res_5 = set1 - set2 # 取set1独有
res_6 = set2 - set1 # 取set2独有
res_7 = set1.difference(set2) # 取set1独有
res_7 = set2.difference(set1) # 取set2独有

# 对称差集
res_8 = set1 ^ set2 
res_9 = set1.symmetric_difference(set2)

# 父子集:issuperset 大于，issubset小于
set3 = {1,2,3}
set4 = {1,2}
set5 = {1,2,4}
res_10 = set3 > set4 
res_11 = set3 > set5
res_12 = set5 > set4
print(res_10,res_11,res_12) # True false True

set.discard(目标元素)：删除目标元素，不存在时do nothing
set.pop():删除最后一个，可以理解为随机删除
set.remove(目标元素)：删除目标元素，不存在时报错
set.update(set1):更新元集合数据
set.add():添加
set.isdisjoint(set1):两个集合是否完全独立

posted @ 2022-10-31 09:48 转角90 阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

转角90

python数据类型

公告