Python数据类型

数据类型

数字（整型，长整型，浮点型，复数）
字符串
列表
字典
元组
集合

按照以下几点去学习数据类型：

------------------基本使用-----------------------
1.用途
2.定义方式
3.常用操作+内置方法
-------------------数据类型总结-------------------
1.存在一个值 or 多个值
2.有序 or 无序
3.可变 or 不可变（1.可变：值变，id不变。可变 ==不可hash；2.不可变：值变，id就变。不可变 ==可hash）

一、数字

整型与浮点型

#整型int 
			作用：年纪，等级，身份证号，qq号等整型数字相关。
			定义： age = 18  本质上 age是整型int 即： age= int(10)
#浮点型float：
            作用：薪资，身高，体重，等浮点数相关，
            定义：salary = 9999.9  本质上是：salary = float(9999.9)

#二进制，十进制，八进制，十六进制

二、字符串

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

#定义：在单引号\双引号\三引号内，由一串字符组成
name='egon'

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in

#5、移除空白strip
#6、切分split
#7、循环

需要掌握的操作
#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit

示例

name = 'zangjunha o'
#按索引值取，正向/反向取值
# print(name[2]) #正向
# print(name[-1])#反向

#切片
# print(name[1:]) #切片顾头不顾尾
# print(name[:-1])

#长度 (len)
# print(len(name))

#成员计算  in/not in
print( 'a' in name)
print('w' in name)
print('w' not in name)

#移除空白 （strip）

print(name.strip()) #移除字符串尾部空格

print(name.lstrip())#移除字符串左边空格
print(name.rstrip()) #移除字符串右边空格

#切分（split） #切分实际是把字符串放在列表中进行下标取值
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))
name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

#大小写 （lower,upper）
print(name.lower())  # 转小写
print(name.upper())  # 将字符串全部转成大写

#  判断字符串起始/结束 （startswith，endswith）
print(name.startswith('li'))  #
print(name.endswith('li')) # 判断并返回布尔值

#format的三种玩法

res='{} {} {}'.format('egon',18,'male')
print(res)
res='{1} {0} {1}'.format('egon',18,'male')
print(res)
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
print(res)

#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())

三、列表

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[ ] 内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取      
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、追加  list.append()
#6、删除  list.pop(),list.remove(),list.del()
#7、循环
1 l=[1,2,3] #l=list([1,2,3])
  2 # print(type(l))
  3 
  4 #pat1===》优先掌握部分
  5 # 　索引：l=[1,2,3,4,5]
  6 　　　　　 print(l[0])  7 # 　切片
  8 l=['a','b','c','d','e','f']
  9 
 10 # print(l[1:5])
 11 # print(l[1:5:2])
 12 # print(l[2:5])
 13 # print(l[-1])
 14 
 15 
 16 #了解
 17 # print(l[-1:-4])
 18 # print(l[-4:])
 19 # l=['a','b','c','d','e','f']
 20 # print(l[-2:])
 21 
 22 # 　　追加
 23 # hobbies=['play','eat','sleep','study']
 24 # hobbies.append('girls')
 25 # print(hobbies)
 26 
 27 # 　　删除
 28 hobbies=['play','eat','sleep','study']
 29 # x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值
 30 # print(x)
 31 # print(hobbies)
 32 
 33 # x=hobbies.pop(0)
 34 # print(x)
 35 #
 36 # x=hobbies.pop(0)
 37 # print(x)
 38 
 39 #队列：先进先出
 40 queue_l=[]
 41 #入队
 42 # queue_l.append('first')
 43 # queue_l.append('second')
 44 # queue_l.append('third')
 45 # print(queue_l)
 46 #出队
 47 # print(queue_l.pop(0))
 48 # print(queue_l.pop(0))
 49 # print(queue_l.pop(0))
 50 
 51 
 52 #堆栈:先进后出，后进先出
 53 # l=[]
 54 # #入栈
 55 # l.append('first')
 56 # l.append('second')
 57 # l.append('third')
 58 # #出栈
 59 # print(l)
 60 # print(l.pop())
 61 # print(l.pop())
 62 # print(l.pop())
 63 
 64 #了解
 65 # del hobbies[1] #单纯的删除
 66 # hobbies.remove('eat') #单纯的删除，并且是指定元素去删除
 67 
 68 
 69 # 　　长度
 70 # hobbies=['play','eat','sleep','study']
 71 # print(len(hobbies))
 72 
 73 # 　　包含in
 74 # hobbies=['play','eat','sleep','study']
 75 # print('sleep' in hobbies)
 76 
 77 # msg='hello world egon'
 78 # print('egon' in msg)
 79 
 80 
 81 ##pat2===》掌握部分
 82 hobbies=['play','eat','sleep','study','eat','eat']
 83 # hobbies.insert(1,'walk')
 84 # hobbies.insert(1,['walk1','walk2','walk3'])
 85 # print(hobbies)
 86 
 87 # print(hobbies.count('eat'))
 88 # print(hobbies)
 89 # hobbies.extend(['walk1','walk2','walk3'])
 90 # print(hobbies)
 91 
 92 hobbies=['play','eat','sleep','study','eat','eat']
 93 # print(hobbies.index('eat'))
 94 
 95 
 96 #pat3===》了解部分
 97 hobbies=['play','eat','sleep','study','eat','eat']
 98 # hobbies.clear()
 99 # print(hobbies)
100 
101 # l=hobbies.copy()
102 # print(l)
103 
104 # l=[1,2,3,4,5]
105 # l.reverse()
106 # print(l)
107 
108 l=[100,9,-2,11,32]
109 l.sort(reverse=True)
110 print(l)

四、元组

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
#定义：与列表类型比，只不过[]换成()
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取   
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环

t=(1,[1,3],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
# print(type(t))

# #元组可以作为字典的key
# d={(1,2,3):'egon'}
# print(d,type(d),d[(1,2,3)])

# 　　　　切片
# goods=('iphone','lenovo','sanxing','suoyi')
# print(goods[1:3])

# 　　　　长度

#in:
#字符串:子字符串
#列表：元素
#元组：元素
#字典：key

# goods=('iphone','lenovo','sanxing','suoyi')
# print('iphone' in goods)看的是里面的元素在不在里面

# d={'a':1,'b':2,'c':3}
# print('b' in d) 看的是key在不在d里面

#掌握
# goods=('iphone','lenovo','sanxing','suoyi')
# print(goods.index('iphone'))
# print(goods.count('iphone'))

#补充：元组本身是不可变的，但是内部的元素可以是可变类型
t=(1,['a','b'],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))

# t[1][0]='A'
# print(t)
# t[1]='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'


age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

五、字典

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

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)

#优先掌握的操作：
#1、按key存取值：可存可取
#2、长度len
#3、成员运算in和not in

#4、删除 pop(),popiteam()
#5、增加 update({})
#6、存/取 键keys()，值values()，键值对items()
#7、循环

字典的表示方法：

info_dic={'name':'haiyna','age':18,'sex':'female'}
# 常用操作：
#
1.存/取
info_dic={'name':'egon','age':18,'sex':'male'}
  print(info_dic['name11111111'])#找不到则报错了
  print(info_dic.get('name',None))
  print(info_dic.get('name222222',None))#get方法找不到不报错，可以自己设定默认值

#pop：key存在则弹出值，不存在则返回默认值，如果没有默认值则报错
# print(info_dic.pop('nam123123123123123123e',None))
# print(info_dic)

# print(info_dic.popitem())
# print(info_dic)

# info_dic['level']=10
# print(info_dic)

#
# 　　　　删除
info_dic={'name':'egon','age':18,'sex':'male'}
# info_dic.pop()
# info_dic.popitem()

# del info_dic['name']


#
# 　　　　键s，值s，键值对
info_dic={'name':'egon','age':18,'sex':'male'}
# print(info_dic.keys())
# print(info_dic.values())
# print(info_dic.items())

# for k in info_dic:
#     # print(k,info_dic[k])
#     print(k)

# print('========>')
# for k in info_dic.keys():
#     print(k)

# for val in info_dic.values():
#     print(val)

# for k,v in info_dic.items(): #k,v=('name', 'egon')
#     print(k,v)



# 　　　　长度
# info_dic={'name':'egon','age':18,'sex':'male'}
# print(len(info_dic))
#
# 　　　　循环
#
# 　　　　包含in

# info_dic={'name':'egon','age':18,'sex':'male'}
# print('name' in info_dic)
# print('name' in info_dic.keys())
# print('egon' in info_dic.values())
# print(('name','egon') in info_dic.items())



#掌握
info_dic={'name':'egon','age':18,'sex':'male'}
# info_dic.update({'a':1,'name':'Egon'})
# print(info_dic)

# info_dic['hobbies']=[]
# info_dic['hobbies'].append('study')
# info_dic['hobbies'].append('read')
# print(info_dic)

#setdefault:key不存在则设置默认值，并且放回值默认值
#key存在则不设置默认，并且返回已经有的值

# info_dic.setdefault('hobbies',[1,2])
# print(info_dic)
# info_dic.setdefault('hobbies',[1,2,3,4,5])
# print(info_dic)

# info_dic={'name':'haiyan','age':18,'sex':'male'}

# {'name':'egon','age':18,'sex':'male','hobbies':['study']}
# info_dic.setdefault('hobbies',[]).append('study')

# {'name':'egon','age':18,'sex':'male','hobbies':['study','read']}
# info_dic.setdefault('hobbies',[]).append('read')

# {'name':'egon','age':18,'sex':'male','hobbies':['study','read','sleep']}
# info_dic.setdefault('hobbies',[]).append('sleep')
# l=info_dic.setdefault('hobbies',[])
# print(l,id(l))
# print(id(info_dic['hobbies']))

# print(info_dic)



#了解
# d=info_dic.copy()
# print(d)
# info_dic.clear()
# print(info_dic)

# d=info_dic.fromkeys(('name','age','sex'),None)
# print(d)
# d1=dict.fromkeys(('name','age','sex'),None)
# d2=dict.fromkeys(('name','age','sex'),('egon',18,'male'))
# print(d1)
# print(d2)

# info=dict(name='haiyan',age=18,sex='male')
# print(info)

#
# info=dict([('name','haiyan'),('age',18)])
# print(info)

六、集合

一、集合的作用

知识点回顾：可变类型是不可hash类型，不可变类型是可hash类型

作用：去重，关系运算

定义：可以包含多个元素，用逗号分割，集合的元素遵循三个原则：

1.每个元素必须是不可变类型（可hash，可作为字典的key）

2.没有重复的元素

4.无序

注意集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无需纠结集合中的单个值
二、常用方法

in 和 not in

|并集（print(pythons.union(linuxs))）

&交集（print(pythons.intersection(linuxs))）

-差集（print(pythons.difference(linuxs))）

^对称差集（print(pythons.symmetric_difference(linuxs))）

==

>，>= ，<,<= 父集（issuperset），子集（issuberset）

,>=,<,<=
set1={1,2,3,4,5}
set2={1,2,3,4}
print(set1 >= set2)
print(set1.issuperset(set2))
set1={1,2,3,4,5}
set2={1,2,3}
print(set1<=set2)
print(set1.issubset(set2))

三、练习

一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　pythons={‘haiyan’,‘fank’,‘yaling’,‘lalal’,‘haidong’,‘biubiu’}
linuxs={‘six’,‘wu’,‘dabao’}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
#　1. 求出即报名python又报名linux课程的学员名字集合

 print(pythons & linuxs)

#　2. 求出所有报名的学生名字集合

 print(pythons | linuxs)

#　3. 求出只报名python课程的学员名字

print(pythons - linuxs)

#　4. 求出没有同时这两门课程的学员名字集合

print(pythons ^ linuxs)

四、方法

==掌握部分=

linuxs={‘six’,‘wu’,‘dabao’}
linuxs.add(‘xiaoxiao’)#说明set类型的集合是可变类型
linuxs.add([1,2,3])#报错，只能添加不可变类型
print(linuxs)

linuxs={‘six’,‘wu’,‘dabao’}

res=linuxs.pop() #不用指定参数,随机删除,并且会有返回值
print(res)

res=linuxs.remove(‘wupeiqi’)#指定元素删除，元素不存在则报错，单纯的删除，没有返回值，
print(res)

res=linuxs.discard(‘egon1111111111’) #指定元素删除，元素不存在不报错，单纯的删除，没有返回值，

=了解部分=

linuxs={‘wupeiqi’,‘egon’,‘susan’,‘hiayan’}
new_set={‘xxx’,‘fenxixi’}
linuxs.update(new_set)
print(linuxs)
linuxs.copy()
linuxs.clear()

#解压

a,*_={‘zzz’,‘sss’,‘xxxx’,‘cccc’,‘vvv’,‘qqq’}
print(a)