位置：首页-资讯-后端开发

Python数据类型总结

2023-01-31 01:16

短信预约 -IT技能 免费直播动态提醒

第1章数据类型：

1.1可变or不可变类型（变量值）：

变量的三个特点：id/type/value

可变类型：值改变，但id不变，证明就是在改变原值

不可变类型：值改变，id也跟着变了，证明申请了新的内存空间来存新值，根本没有改变量值

Ø 证明浮点型是不可变类型

x=1.1
print(id(x))
x=1.2
print(id(x))

#4344525016

#4344525136

Ø 证明int是不可变类型：

x=10
print(id(x))
x=11
print(id(x))

#4457767232
#4457767264

Ø 证明列表是可变类型：

h=['a','b','c']
print(id(h))
h[0]='J'#修改列表中的某一个值
print(id(h))

#4498034504

Ø 证明字典是可变类型：

h={'x':1,'y':2}
print(id(h))
h['x']=10
print(id(h))

#4363789224

1.2什么是数据？

X=10 10就是我们要存储的数据

1.3为何数据要分不同的数据类型？

数据是用来表示状态的，不同的状态就应该用不同的数据去表示

1.4数据类型：

1.4.1数字（×××，长整型，浮点型，复数）

定义×××方式：

x=int(10)
print(type(x))

定义浮点型方式：

x=float(1.22)
print(type(x))

1.4.2字符串str

作用：名字，性别，国籍，地址等描述信息

定义：在单引号、双引号、三引号内，由一串字符组成

x=str('jiang')
print(type(x))

str类型可以将任意类型转成字符串类型：

x=str({'a':1})
print(x,type(x))

name='*egon**'
print(name.strip('*'))取*号中间的部分
print(name.lstrip('*'))取*号左边的部分
print(name.rstrip('*'))取*号右边的部分
name='egon'
print(name.lower())#变成小写
print(name.upper())#变成大写
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串
#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

求字符串的长度：

j='asd'
print(len(j))

成员运算in和not in ：判断一个子字符换是否存在于一个大字符串中

name='my name is jiang,jiang is man'
print('jiang' in name)

移除字符串左右两边的空白：

name=' hello '
res=name.strip(' ')
print(res)

name='***hello***'
res=name.strip('*')
print(res)

切分split：

info='root:x:0:0::/root:/bin/bash'
res=info.split(':')
print(res[0])

练习：

移除name变量对应的值两边的空格，并输出处理结果

name=' aleX'
a=name.strip()
print(a)

判断name变量对应的值是否以“al”开头，并输出结果

name=' aaleX'
if name.startswith(al):
print(name)
else:
print('no')

判断name变量对应的值是否以“x”结尾，并输出结果

name=' aaleX'
if name.endswith(name):
print(name)
else:
print('no')

将name变量对应的值中的“1”替换为“p”，并输出结果

name=' aleX'
print(name.replace('l','p'))

将name变量对应的值根据“l”分隔，并输出结果

name=' aleX'
print(name.split('l'))

将name变量对应的值变大写，然后输出结果

name=' aleX'
print(name.upper())

将name变量对应的值变小写，然后输出结果

name=' aleX'
print(name.lower())

请输出name变量的值的第2个字符

name=' aleX'
print(name[1])

请输出name变量对应的值中“e”所在索引的位置

name=' aleX'
print(name.index('e'))

获取子序列，去掉最后一个字符

name=' aleX'
a=name[:-1]
print(a)

1.4.3列表

作用：多个装备，多个爱好，多门课程等

定义：[]内可以有多个任意类型的值，逗号分隔

name=['a','b','c']
print(name,type(name))

按照索引取值改值：

name=['a','b','c']
print(name)
name[-1]='A'
print(name[-1])

增加列表的元素：

name=['a','b','c']
name.append('jiang')
print(name)

删除列表的元素

name=['a','b','c']
del name[0]
print(name)
name.remove('b')
print(name)

切片：

name=['a','b','c']
print(name[0:2])

计算长度（就是计算列表中元素的个数）：

name=['a','b','c']
print(len(name))

成员运算in和not in：

name=['a','b','c']
print('jiang' in name)

计算个数：

name=['a','b','c','a']
print(name.count('a'))

查看索引，默认找到第一个就返回找不到则报错：

name=['a','b','c','a']
print(name.index('a'))

排序：

name=[11,-3,0,99,88]
name.sort()
print(name)

反转：

name=[11,-3,0,99,88]
name.reverse()
print(name)

name=[11,-3,0,99,88]
res=name[::-1]
print(res)

1.4.4元组

作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要用来读

定义：与列表类型比，只不过[]换成（）

1.4.5字典

作用：存多个值，key-value存取，取值速度快

定义：key必须是不可变类型，value可以是任意类型

1.4.6集合

作用：去重，关系运算

定义：可变类型是不可hash类型，不可变类型是可hash类型

定义集合：在{}内用逗号隔开

x={1,3,5,6,7,1,1}
print(x)

如何造一个空集合：

x={}
print(type(x))

s=set()
print(type(s))

长度计算

s={1,2,2,3}
print(len(s))

成员运算

s={'egon','alex','oldboy'}
print('jiang' in s)

关系运算：

python_stu=['egon','alex','kevin','王大炮','李二丫']
linux_stu=['张铁蛋','刘铜蛋','赵金蛋','alex','oldboy','kevin']

res=[]
for stu1 in python_stu:
if stu1 in linux_stu:
res.append(stu1)

print(res)

交集

python_stu={'egon','alex','kevin','王大炮','李二丫'}
linux_stu={'张铁蛋','刘铜蛋','赵金蛋','alex','oldboy','kevin'}

print(python_stu& linux_stu)

print(python_stu.intersection(linux_stu))

合集

print(python_stu | linux_stu)

print(python_stu.union(linux_stu))

差集

print(python_stu - linux_stu)

print(python_stu.difference(linux_stu))

对称差集

print((python_stu - linux_stu) | (linux_stu - python_stu))
print(python_stu ^ linux_stu)

print(python_stu.symmetric_difference(linux_stu))

x={1,2,3}
y={1,3,2}
print(x== y)

父集（>= ）

s={1,2,3,4}
y={1,2,3}
print(s>= y)

print(s.issuperset(y))

子集(<=)

s={1,2,3}
y={1,2,3,4}
print(s<= y)

print(s.issubset(y))

1.4.7数据类型的总结：

按存储空间的占用从低到高

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，需要处理数据的增删改

练习

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
print(pythons| linuxs)#求出所有报名学生名字集合
print(pythons& linuxs)#求出同时报这两个课程的集合
print(pythons- linuxs)#求出只报了python的学生
print(pythons^ linuxs)#没有同事报两个课程的集合

去重：

　　1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

l=['a','b',1,'a','a']
print(set(l))

　　2.在上题的基础上，保存列表原来的顺序

l=['a','b',1,'a','a']
ll=[]
for iin l:
if i not in ll:
ll.append(i)
print(ll)

利用集合

l=['a','b',1,'a','a']
ll=[]
s=set()
for iin l:
    if i not in s:
        s.add(i)
        ll.append(i)
print(ll)

3.去除文件中重复的行，肯定要保持文件内容的顺序不变

import os
with open('db.txt','r',encoding='utf-8') as read_f,\
     open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

　　4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

l=[

{'name':'egon','age':18,'sex':'male'},

{'name':'alex','age':73,'sex':'male'},

{'name':'egon','age':20,'sex':'female'},

{'name':'egon','age':18,'sex':'male'},

]

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
s=set()
ll=[]
for i in l:
    val=(i['name'],i['age'],i['sex'])
    if val not in s:
        s.add(val)
        ll.append(i)
print(ll)