python数据类型详解

前言

首先，我们要知道什么是数据，为什么数据要分为不同的类型，数据类型有哪些，下来就跟着kismile来学习，这个叼逼的py。

1、数据就是，之前定义的value比如，x=10，10就是数据
2、为何吧数据分为不同的类型：数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
3、数据类型：
数字（整形，长整形，浮点型，复数）
字符串
字节串：在介绍字符编码时介绍字节bytes类型
列表
元组
字典
集合
4、数据类型学习：
基本使用：
1、用途
2、定义方式
3、常用操作+内置的方法
该类型总结：
1、存在一个值or存在多个值
只能存在一个值
可以存在多个值，值都可以是什么类型
2、有序or无序
3、可变or不可变
！！！可变：值变，id不变，可变==不可hash
！！！不可变：值变，id变，不可变==可hash

数字

[b]整型与浮点型(int/float)：[/b]

#整型int
作用：年纪、等级、qq号
定义：
age=10 #本质age=int(10)
#浮点型float
作用：薪资，身高，体重
定义：
salary=300.3 #本质salary=float(300.3)

#其他数字类型（了解）
#长整型（了解
4000
）
python2中出现，python3没有这个定义
>>> num=2L
>>> type(num)
<type 'long'>
#复数（了解）
>>> x=1-2j
>>> x.real
1.0
>>> x.imag
-2.0

[b]整数类型总结：[/b]

1、存一个值or存多个值
只能存一个值

2、有序

3、可变or不可变
！！！不可变：值变，id就变。不可变==可hash

字符串

字符串(str)

#字符串：
作用：名字、性别、国籍
定义：在单引号、双引号、三引号内，由一串字符组成
msg='hello world'

优先掌握的操作：

1、按索引取值（正向取+反向取）：只能取

msg='hello world'
print(msg[0],type(msg[0]))
print(msg[-1])      #倒序取值，倒数第一个为-1
>>>
>h <class 'str'>
>d
#注意：字符串，可以实现使用索引取值，元素为每个字符（包含空格）

2、切片（顾头不顾尾，步长）

print(msg[0:7])     #>=0   <7
print(msg[0:7:1])   #>=0   <7     步长为1
print(msg[0:1:2])   #>=0   <1     步长为2
print(msg[3:1:-1])  #>=3   <1     步长为-1（也就是倒序）从第4个值开始取，取到第一个值（第一个值不算），倒序取
print(msg[-1::-1])   #倒序取值，从倒数第一个值，取到索引0
print(msg[0::-1])   #倒序取值，第0个值，取到0（也就是说包含索引0的值）

3、长度len

print(msg._len_())#或者使用下面的
print(len(msg))#计算值的总长度，一共多少个字符

4、成员运算in和not in

msg='hello world'
print('he' in msg)  #返回True，因为he这个字符在msg中
print('sdfs' in msg)

5、移除空白strip

use skill：

strip() #默认去除字符串俩边的空格

password='    123    '
print(password.strip())   #strip()的意思是去除字符串俩边的空格
password=input('password:').strip()   #在输入passwd时，字符前面后面有空格，使用strip会去除俩边的空格，只保留有效的字符串
print(password)

6、切分split()

use skill：

split(‘:’) 以：分割字符

split() 默认以空格分割字符

split(‘\’,1) 以\分割字符，只分割第一部分

user_info='root:x:0:0::/root:/bin/bash'
res=user_info.split(':')  #使用split(':')会默认以:分割,把字符串分割成一个列表
print(res)
>>>
>['root', 'x', '0', '0', '', '/root', '/bin/bash']

cmd='get /root/a/b/c/d.txt'
print(cmd.split())    #split()什么都不添加，会默认以空格为分割符，分割字符串
>>>
>['get', '/root/a/b/c/d.txt']

file_path='C:\\a\\d.txt'
print(file_path.split('\\',1))   #split('\\',1)这里的意思是，以'\\'为分隔符，只分割第一个

7、循环

#使用while：
msg='hel'
size=len(msg)  #计算msg的长度
n=0
while n < size:  #使用变量的值
print(msg
)  #msg
,使用变量作为索引，取msg中的值
n+=1
#使用for：
msg='hel'
for i in msg:
print(i)

字符串需要了解的方法

role_list = ['admin', 'school']
print(('用户角色错误，选项：%s' %','.join(role_list)))
>>>用户角色错误，选项：admin,school

字符串类型总结：

1、存在一个值or存在多个值
只能存在一个值

2、有序

3、可变or不可变
！！！不可变：值变，id变，不可变==可hash

列表类型

[b]列表(list):[/b]

#列表：
作用：多个装备、多个爱好、多门课
定义：[]内可以有多个任意类型的值，逗号分隔
print(list('hello')) #字符串也可用用list来把里面的单个字符拿出来生成一个列表
>>>
>['h', 'e', 'l', 'l', 'o']
#ps:注意：列表其实和字符串有些相似，只是字符串是以字符串为单位，列表是以元素为单位

[b]列表命令使用[/b]

use skill：

min(list)  #最小值
max(list)  #最大值
my_girl_friends.extend(l)   #这个意思是合并俩个列表,追加到之后
a=my_girl_friends.copy()  # 这里的意思是拷贝一份
my_girl_friends.reverse()  # 这里的意思是把列表，倒序排放
l.sort(rev  erse=False)  # 这里sort是用来排序的，reverse=False的意思是顺序排序，reverse=True，倒序排序
my_girl_friends.count('4')  #查看这个值的index
my_girl_friends.clear() #清除列表
my_girl_friends.pop(0)  #pop(0)这里使用索引删除（拿走）这个位置对应的值。
my_girl_friends.remove('alex')  #这里的remove会直接删除（）中的值，但是res拿不到删除的值。
my_gril_friends.append(6)  #这里append(6)，会追加到列表最后。在列表中添加一个元素
my_girl_friends.index('wupeiqi'))  #这index的意思是找出list中第一个元素的索引
my_girl_friends.insert(1,'lqx')  #这里的意思是在索引1之前插入一个元素'lqx'

[b]优先掌握的操作：[/b]

1、按索引取值（正向存取+反向存取）：

注意：列表既可以存也可以取

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends[0]='lqx'
print(my_girl_friends)
>>>
>['lqx', 'wupeiqi', 'yuanhao', 4, 5]

2、切片（顾头不顾尾，步长）

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends[1:3]) #从第一个值取到第3个值（注意这里是有第0个值的）
print(my_girl_friends[0:3:1])   #从第0个值开是到第3个值，步长为1
print(my_girl_friends[0:1:2])   #从第0个值开始到第1个值结束，跳1个取
print(my_girl_friends[3:1:-1])  #从第3个值开始取到第1个值，反向取
print(my_girl_friends[-1::-1])  #倒序取值，取全部值，
print(my_girl_friends[0::-1])   #倒序取值，取第0个值

3、长度

print(len(my_girl_friends)) #这里的长度指的是list有多少个元素

4、成员运算in 和not in

print('alex' in my_girl_friends)
>>>
>True

5、追加 append()

use skill：

append(6) #这里append(6)，会追加到列表最后。在列表中添加一个元素

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends[5]=3   #这里会报错，原因是找不到第5个索引
my_gril_friends.append(6)
print(my_gril_friends)
>>>
>['alex', 'wupeiqi', 'yuanhao', 4, 5, 6]

6、删除 remove() pop()

use skill:

remove(‘列表中的值’) #使用remove会直接删除这个值，拿不到删除的值。

pop(2) #使用pop(2)，这里是按索引删除值（拿走）

#单纯的删除：万能del
del my_girl_friends[0]  #这里就会删除第0个索引所对应的值
#使用remove()删除：
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends)
res=my_girl_friends.remove('alex')  #这里的remove会直接删除（）中的值，但是res拿不到删除的值。
print(my_girl_friends)
print(res)

>>>
>['alex', 'wupeiqi', 'yuanhao', 4, 5]
>['wupeiqi', 'yuanhao', 4, 5]
>None   #这里

##如果想删除list中的值，并且拿到这个值。
res=my_girl_friends.pop(0)  #pop(0)这里使用索引删除（拿走）这个位置对应的值。
print(my_girl_friends)
print(res)
>>>
>['wupeiqi', 'yuanhao', 4, 5]
>alex
#pop连续删除（拿走）第一个值
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends)
print(my_girl_friends.pop(0)) #alex
print(my_girl_friends.pop(0)) #wupeiqi
print(my_girl_friends.pop(0)) #yuanhao
print(my_girl_friends.pop(0)) #4

7、循环

#while循环：
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

size=len(my_girl_friends)
n=0
while  n < size:
print(my_girl_friends
)
n+=1

#for循环：
for i in my_girl_friends:
print(i)
#ps:注意：这里和字符串的循环相同，只是字符串是以单个字符为元素，list是以单个items为元素。

需要掌握的附加选项

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.clear() #清除列表

my_girl_friends.count('4')  #查看这个值的index

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
l=['lqx','yft']
my_girl_friends.extend(l)   #这个意思是合并俩个列表,追加到之后
print(my_girl_friends)
my_girl_friends.extend('hello') #这里的字符串，会当做一个列表来展现
print(my_girl_friends)
>>>
>['alex', 'wupeiqi', 'yuanhao', 4, 5, 'lqx', 'yft']
['alex', 'wupeiqi', 'yuanhao', 4, 5, 'lqx', 'yft', 'h', 'e', 'l', 'l', 'o']

my_girl_friends.insert(1,'lqx')  #这里的意思是在索引1之前插入一个元素'lqx'
print(my_girl_friends)

a=my_girl_friends.copy() #这里的意思是拷贝一份

my_girl_friends.reverse() #这里的意思是把列表，倒序排放

my_girl_friends=['alex','wupeiqi','wupeiqi','wupeiqi','wupeiqi','yuanhao',4,5]
print(my_girl_friends.index('wupeiqi'))  #这index的意思是找出list中第一个元素的索引

l=[1,10,4,11,2,]
l.sort(reverse=False)  #这里sort是用来排序的，reverse=False的意思是顺序排序，reverse=True，倒序排序
print(l)
>>>
>[1, 2, 4, 10, 11]

列表类型总结：

1、存在一个值or存在多个值
可以存多个值，值都可以是任意类型

2、有序

3、可变or不可变
！！！可变：值变，id不变，可变==不可hash

元组类型

[b]元组(tuple):[/b]

#元组：
作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55) #本质age=tuple((11,22,33,44,55))
print(type(age))
age[0]=12   #元组是不能修改值的

[b]元组命令使用[/b]

use skill：

print(age.index(33))  # 33在age元组中第一次出现的index id
print(age.index(33333)) #如果元组中没有这个元素，会报错
print(age.count(33))  # 33在age元组中出现的总次数

[b]优先掌握的操作：[/b]

1、按索引取值(正向取+反向取)：只能取

2、切片（顾头不顾尾，步长）

3、长度

4、成员运算in和not in

5、循环

age=(11,22,33,44,55)
print(age[0])

print(age[0:3])

print(len(age))

print(11 in age)

for item in age:
print(item)

[b]需要掌握的参数[/b]

age=(11,22,33,44,55)
print(age.index(33))    #33在age元组中第一次出现的index id
#print(age.index(33333)) #如果元组中没有这个元素，会报错

print(age.count(33))   #33在age元组中出现的总次数

[b]列表类型总结：[/b]

1、存在一个值or存在多个值
可以存多个值，值都可以是任意类型

2、有序

3、可变or不可变
！！！不可变：值变，id变，不可变==可hash

字典类型

[b]字典(dict):[/b]

#字典：
作用：存放多个值，key:value，存取速度快
定义：key必须是不可变类型（int,float,str,tuple）,value可以为任意类型
#方法1：
info={'name':'egon','age':18,'sex':'male'} #info=dict({'name':'egon','age':18,'sex':'male'})
#方法2
info2=dict(name='lqx',sex='male',age=18)
print(info2)
#方法3
info3=dict([('name','agen'),('sex','male'),('age',18)])
print(info3)
#方法4
info4={}.fromkeys(['name','sex','age'],None)
print(info4)

[b]字典命令使用[/b]

use skill：

hobbies_list = info.setdefault('hobbies', [])  # 如果字典中没有hobbies，那么就添加一个items，
hobbies_list.append('play')  # 以列表为单位，在列表中添加一个value，会自动添加到字典中的：hobbies的values
info.fromkeys(info)  # 初始化字典，或者list生成字典，str生成字典
info.get('werw', '没有')  # 判断字典中是否存在这个值，后面不加参数，默认返回None
info.pop('name')  # 在dict中取出'name'对应的value，并且在字典中删除item('name':'lqx')
info.popitem()  # 任意删除（拿走）一对key：value
info.update(d)
info.  # 合并字典info和d，重复的key，以d为准
info.setdefault('name', 'lqx')  # 在字典中追加一个items，如果该key在字典中已存在，那么就返回字典中的key对应的value
info.keys()  # 只显示dict中的key
info.items()  # 显示dict中的key和values
info.popitem()
任意删除（拿走）一对key：value
info.pop('name')  # 删除指定的key，但是只能取到key，value会丢失info.

[b]优先掌握的操作：[/b]

1、按key取值，可存可取

info={'name':'lqx','age':18,'sex':'male'}
print(info['name'])
info['name']='yft'
print(info)

2、长度

print(len(info))   #这里的长度是字典中的元素，key：values是一个元素

3、成员运算in和not in

print('lqx' in info)
print('name' in info) #这里的运算只能取key，

4、删除

use skill:

popitem() 任意删除（拿走）一对key：value

pop(‘name’) #删除指定的key，但是只能取到key，value会丢失

print(info.pop('name')) #删除指定key，包括value，但是只能取到key
print(info)
print(info.popitem())   #任意删除（拿走）一对key：value
print(info)

5、键keys(),值values(),键对应items()

use skill:

keys() #只显示dict中的key

items() #显示dict中的key和values

print(info.keys())   #只显示dict中的key
print(list(info.keys())) #把dict中的key当做一个列表显示
print(info.items())  #显示dict中的key和values
print(list(info.items()))   #把dict中的元素（项）以列表的形式展现

6、循环

for item in info:   #这里循环是循环的是dict中的key
print(item)

[b]需要掌握的参数[/b]

use skill:

fromkeys(info)    #初始化字典，或者list生成字典，str生成字典
get('werw','没有')    #判断字典中是否存在这个值，后面不加参数，默认返回None
pop('name')    #在dict中取出'name'对应的value，并且在字典中删除item('name':'lqx')
info.popitem()    #任意删除（拿走）一对key：value
info.update(d)    #合并字典info和d，重复的key，以d为准
setdefault('name','lqx')    #在字典中追加一个items，如果该key在字典中已存在，那么就返回字典中的key对应的value

info = {'name': 'lqx', 'age': 18, 'sex': 'male'}
li=['name','age','sex']
print(info.fromkeys(info))  #从新生成字典，（或者初始化字典中的values）

print(info.get('werw'))    #如果字典中不存在这个key，会默认返回None，如果字典存在，返回values
print(info.get('werw','没有'))  #后面添加参数，表示字典中不存在，返回后面的值

print(info.pop('name'))   #取出'name'对应的value
print(info)
print(info.popitem())    #任意删除（拿走）一对key：value

info = {'name': 'lqx', 'age': 18, 'sex': 'male'}
d={'x':1,'y':2,'name':'EGON'}
info.update(d)   #字典info和字典d合并，重复的以字典d为准
print(info)

info={'name':'egon','sex':'male'}
value=info.setdefault('age',18)   #在字典中追加一个item
info.setdefault('brith','1990')
v=info.setdefault('name','lqx')    #如果字典中已经存在keys,那么不会修改字典，返回字典中keys对应的values
print(value)
print(info)
print(v)
>>>
>18
>{'name': 'egon', 'sex': 'male', 'age': 18, 'brith': '1990'}
>egon

###dict和list连用
info={'name':'egon'}
info['hobbies']=[]   #在字典中添加一个items，对应的值为list[]
print(info['hobbies'])
print(info)
info['hobbies'].append('music') #在key为hobbies的values中添加一个值
print(info)
info['hobbies'].append('read')
print(info)
>>>
>[]
>{'name': 'egon', 'hobbies': []}
>{'name': 'egon', 'hobbies': ['music']}
>{'name': 'egon', 'hobbies': ['music', 'read']}

##练习
#如果字典info中没有hobbies，那么就添加[]一个列表；如果有hobbies这个key，那么就添加一个value
d=input('>>:')
info={'name':'egon'}
if 'hobbies' not in info:
info['hobbies']=[]
else:
info['hobbies'].append(d)
print(info)
#练习2：
info={'name':'egon'}
hobbies_list=info.setdefault('hobbies',[])  #如果字典中没有hobbies，那么就添加一个items，
print(hobbies_list)
print(info)
hobbies_list.append('play')  #以列表为单位，在列表中添加一个value，会自动添加到字典中的：hobbies的values
hobbies_list.append('read')
print(info)

[b]字典类型总结：[/b]

1、存在一个值or存在多个值
可以存多个值，值都可以是任意类型

2、无序

3、可变or不可变
！！！可变：值变，id不变，可变==不可hash

集合

[b]集合(set):[/b]

#集合：
作用：关系运算，去重
定义集合：{}内用逗号分隔每个元素都必须为**不可变类型**，元素不能重复，无序，一定是不能使用list，dict

s={1,2,3,1} #s=set({1,2,3,1})

[b]集合命令使用[/b]

use skill：

print(s1.difference(s2))  #对比s1，与s2不同的地方，并打印
s1.difference_update(s2)   #去除，s1里面与s2相同的部分
print(s2.pop())  #随机拿出一个
s2.add('b')  #添加一个元素
s2.discard(12312)   #删除12312元素，如果没有，则不删除，返回s2里面全部的内容
s2.remove(1)  #删除的元素不存在则报错
print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True
s2.update({5,6,7,8})  #添加一个集合到另一个结合
print(list(set(l)))    #去除list中重复的元素

[b]优先掌握的操作：[/b]

1、长度

2、成员运算in 和not in

3、| 合集

4、& 交集

5、^ 对称差集

6、- 差集

7、父集:>,>=,子集：<，<=

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

print(2 in s)

se={5,6,7,8}
print(s | se)

print(s & se)

print(s ^ se)

print(s - se)

print(se - s)

l={1,2,3}
le={1,2,3,4,5,6}
print(l <= le)

[b]需要掌握的参数[/b]

s1={1,2,3}
s2={1,2}
print(s1 - s2)
print(s1.difference(s2))  #对比s1，与s2不同的地方，并打印
print(s1,s2)
s1.difference_update(s2)   #去除，s1里面与s2相同的部分
print(s1,s2)

s2={1,2,3,3,'a'}
print(s2)
#print(s2.pop())  #随机拿出一个

s2.add('b')  #添加一个元素
print(s2)

s2.discard(12312)   #删除12312元素，如果没有，则不删除，返回s2里面全部的内容
print(s2)
s2.remove(1)  #删除的元素不存在则报错

s1={1,2,3,4,5,'a'}
s2={'b','c',}
print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True

s2={1,2,3,4,5,'a'}
s2.update({5,6,7,8})  #添加一个集合到另一个结合
print(s2)

l=['a','b',1,'a','a'] #list
print(list(set(l)))    #去除list中重复的元素

数据类型总结：

[b]按存储空间的占用分（从低到高）[/b]

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

[b]按存值个数区分[/b]

标量／原子类型    数字，字符串
容器类型         列表，元组，字典

[b]按可变不可变区分[/b]

可变      列表，字典
不可变     数字，字符串，元组

[b]按访问顺序区分[/b]

直接访问                    数字
顺序访问（序列类型）          字符串，列表，元组
key值访问（映射类型）         字典

[b]按是否可hash[/b]

不可hash      列表，字典
可hash       数字，字符串，元组