python数据类型详解

整型与浮点型(int/float)：

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

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

整数类型总结：

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[n])  #msg[n],使用变量作为索引，取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

列表(list):

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

列表命令使用

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'

优先掌握的操作：

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])
    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

元组(tuple):

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

元组命令使用

use skill：

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

优先掌握的操作：

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)

需要掌握的参数

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

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

列表类型总结：

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

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

字典(dict):

#字典：
	作用：存放多个值，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)

#字典命令使用

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.

优先掌握的操作：

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)   

需要掌握的参数

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)

字典类型总结：

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

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

集合(set):

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

集合命令使用

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中重复的元素

优先掌握的操作：

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)

需要掌握的参数

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中重复的元素

数据类型总结：

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

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

按存值个数区分

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

按可变不可变区分

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

按访问顺序区分

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

按是否可hash

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