基本数据类型

一 数字类型

特性：

只能存放一个值  

一经定义，不可更改

直接访问　

分类：

整型int：年级，等级，身份证号，QQ号，level = 10

浮点型float：身高（height=1.81），体重，薪资（salary=3.3），温度，价格，

二 字符串类型

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

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

 # 字符串的常用操作

需要优先掌握的：

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

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#lower,upper
name='egon'
print(name.lower())
print(name.upper())

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#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)) #从右开始切分

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

了解部分：

#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon	hello'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

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

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

示例

 总结：

strip()移除空白，也可以去除其他的字符  

slipt()分割,默认以空格分割。也可以以其他的字符分割  

len()长度  切片：如print(x[1:3])也是顾头不顾尾   
               print(x[0:5:2])#0 2 4

capitalize()首字母大写

center()居中显示例如：x='hello'  print(x.center(30,'#'))

count():计数，顾头不顾尾，统计某个字符的个数，空格也算一个字符  

endswith()以什么结尾

satrtswith()以什么开头

find()查找字符的索引位置，如果是负数，代表查找失败   

index()索引

find()和index()的区别:
  相同：都可以查找字符串含有字符索引
  不同：查找字符串不包含的字符，find返回-1，index保错  

format()字符串格式化    
  1.msg='name:{},age:{},sex:{}'           
    print(msg.format('haiyan',18,女))  

　2.msg='name:{0},age:{1},sex:{0}'     
    print(msg.format('aaaaaa','bbbbbb'))    

　3.msg='name:{x},age:{y,sex:{z}'     
    print(msg.format(x='haiyan',y='18',z='女'))  

isdigit()判断是否是数字

islower()判断是否是全部小写

isupper()判断是否是全部大写

lower()全部转换为小写

upper()全部转换为大写

isspace()判断是否是全都是空格

istitle()判断是否是标题（首字母大写）  

swapcase()大小写字母翻转

join()连接

repalce()替换   

   msg='hello alex'   

   print(msg.replace('e'),'A',1)  

   print(msg.replace('e'),'A',2)

ljust()左对齐   

　　X='ABC'    print(x.ljust(10,'*'))

 三 列表

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

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

列表常用操作：

l=[1,2,3]   # l=list([1,2,3])
# print(type(l))

#pat1===》优先掌握部分
# 　索引：l=[1,2,3,4,5]
print(l[0])  7 # 　切片
l=['a','b','c','d','e','f']

# print(l[1:5])
# print(l[1:5:2])
# print(l[2:5])
# print(l[-1])


#了解
# print(l[-1:-4])
# print(l[-4:])
# l=['a','b','c','d','e','f']
# print(l[-2:])

# 　　追加
# hobbies=['play','eat','sleep','study']
# hobbies.append('girls')
# print(hobbies)

# 　　删除
hobbies=['play','eat','sleep','study']
# x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值
# print(x)
# print(hobbies)

# x=hobbies.pop(0)
# print(x)
#
# x=hobbies.pop(0)
# print(x)

#队列：先进先出
queue_l=[]
#入队
# queue_l.append('first')
# queue_l.append('second')
# queue_l.append('third')
# print(queue_l)
#出队
# print(queue_l.pop(0))
# print(queue_l.pop(0))
# print(queue_l.pop(0))


#堆栈:先进后出，后进先出
# l=[]
# #入栈
# l.append('first')
# l.append('second')
# l.append('third')
# #出栈
# print(l)
# print(l.pop())
# print(l.pop())
# print(l.pop())

#了解
# del hobbies[1] #单纯的删除
# hobbies.remove('eat') #单纯的删除，并且是指定元素去删除


# 　　长度
# hobbies=['play','eat','sleep','study']
# print(len(hobbies))

# 　　包含in
# hobbies=['play','eat','sleep','study']
# print('sleep' in hobbies)

# msg='hello world egon'
# print('egon' in msg)


##pat2===》掌握部分
hobbies=['play','eat','sleep','study','eat','eat']
# hobbies.insert(1,'walk')
# hobbies.insert(1,['walk1','walk2','walk3'])
# print(hobbies)

# print(hobbies.count('eat'))
# print(hobbies)
# hobbies.extend(['walk1','walk2','walk3'])
# print(hobbies)

hobbies=['play','eat','sleep','study','eat','eat']
# print(hobbies.index('eat'))


#pat3===》了解部分
hobbies=['play','eat','sleep','study','eat','eat']
# hobbies.clear()
# print(hobbies)

# l=hobbies.copy()
# print(l)

# l=[1,2,3,4,5]
# l.reverse()
# print(l)

l=[100,9,-2,11,32]
l.sort(reverse=True)
print(l)

四 元祖

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

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

#为何要有元组，存放多个值，元组不可变，更多的是用来做查询
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'

五 字典

#作用：存多个值,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)

字典的表示方法：

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:没有重复的元素
             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

常用方法：

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={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
 linuxs={'wupeiqi','oldboy','gangdan'}
　1. 求出即报名python又报名linux课程的学员名字集合
　2. 求出所有报名的学生名字集合
　3. 求出只报名python课程的学员名字
　4. 求出没有同时这两门课程的学员名字集合

pythons={'haiyan','fank','yaling','lalal','haidong','biubiu'}
linuxs={'six','wu','dabao'}
#　1. 求出即报名python又报名linux课程的学员名字集合

pythons={'haiyan','fank','yaling','lalal','haidong','biubiu'}
linuxs={'six','wu','dabao'}

print(pythons & linuxs)
#　2. 求出所有报名的学生名字集合

pythons={'haiyan','fank','yaling','lalal','haidong','biubiu'}
linuxs={'six','wu','dabao'}

print(pythons | linuxs)
#　3. 求出只报名python课程的学员名字　

pythons={'haiyan','fank','yaling','lalal','haidong','biubiu'}
linuxs={'six','wu','dabao'}　　

print(pythons - linuxs)
#　4. 求出没有同时这两门课程的学员名字集合　

pythons={'haiyan','fank','yaling','lalal','haidong','biubiu'}
linuxs={'six','wu','dabao'}　

print(pythons ^ linuxs)

方法：

# ========掌握部分=======

linuxs={'six','wu','dabao'}

linuxs.add('xiaoxiao')#说明set类型的集合是可变类型
linuxs.add([1,2,3])#报错，只能添加不可变类型
print(linuxs)

# 2.
linuxs={'six','wu','dabao'}

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

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

# 4.
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)

 七 数据类型总结

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

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

按存值个数区分

标量/原子类型：数字，字符串

容器类型： 列表，元祖，字典

按可变不可变区分

可变： 列表，字典

不可变：数字，字符串，元祖

按访问顺序区分

直接访问： 数字

顺序访问（序列类型）：字符串，列表，元祖

key值访问（映射类型）:字典