第二篇 基本数据类型

一、数字类型
1:int
2：fload
如果数字或者字符串比较少的时候比如a=123，b=123，id号是一样的，id号一样，内存空间就一样，值就一样，但值比较大或者字符串比较长时，a=hello world ni hao，b=hello world ni hao，id号就不一样了，就要申请两块内存空间了

image.png

a和b的值是相等的，但内存空间却不一样
二、字符串类型

name='egon'
# 按索引取值
print(name[0]),字符串正向取
print(name[-2])，反向取
# 切片（顾头不顾尾，步长）
print(name[1:3])打印出来的是go
msg='hello world'
print(msg[1:7])打印出来为ello w，注意顾头不顾尾
print(msg[1:7:2])表示步长为2，打印出来为el
msg='abcdefg'
print(msg[::2])不写标书全取
print(msg[5:0:-1])倒着取，了解
# 长度len
msg='abc'
print(len(msg))
# 成员运算in和not in
msg='hello alex'
print('a' in msg)
print('alex' in msg)
print('ax' in msg)必须是连续的才是其中的成员，打印的结果为False

# 移除空白strip
password='123456         '
#password=password.strip()   strip可以去掉两边的空格
#print(password)
print(password.strip())或者直接写成这种格式
msg='*****egon****'
print(msg.strip('*'))#表示去掉*
msg='*****eg**on******'
print(msg.strip('*'))#打印出来为eg**on，说明只能去掉两边的，中间的被认为和字符串为一个整体
# 切分split
user_info='root:x:0:0::/root:/bin/bash'
print(user_info.split(':')[0]) 表示以:为分隔符，全部切分，结果为root
print(user_info.split(':',1)) 不写的时候表示全部切分，写上1表示切分一次，结果为['root', 'x:0:0::/root:/bin/bash']
cmd='put a.txt'
print(cmd.split()[0]) 结果为put。说明默认是以空格作为分隔符
filepath='put /a/b/c/d/a.txt'
print(filepath.split())
msg='alex say i hace on tesla'
print(msg.split(maxsplit=1)[0]) #表示最大切分几次，不常用
#其他操作
msg='****alex***'
print(msg.strip('*'))
print(msg.lstrip('*')) 去掉左边的*
print(msg.rstrip('*')) 去掉右边的*
msg='alex_sb'
print(msg.startswith('alex')) 以什么开头和以什么结尾
print(msg.endswith('sb'))
msg='alex say i have one tesla,my name is alex'
print(msg.replace('alex','sb',1)) #表示把alex替换成sb，不写后面的1表示全部替换，后面的1代表替换的次数
print('my name is %s my age is %s' %('egon',18))
print('my name is {} my age is {}'.format('egon',18))
print('{1} {0} {1}'.format('egon',18))
运行结果
my name is egon my age is 18
my name is egon my age is 18
18 egon 18
print('my name is {x} my age is {y}'.format(y=18,x='egon')) #不用考虑次序
my name is egon my age is 18
#find ,rfind（从右往左找）,index,rindex,count
msg='hello world'
print(msg.find('ell')) #从左到右找，如果有，则返回第一个字符串的索引
print(msg.find('xx')) #从左到右找，如果没有，则返回-1
print(msg.index('d'))  #从左到右找，如果有，则返回第一个字符串的索引
print(msg.index('xx')) #从左到右找，如果没有，则报错
print(msg.find('d',0,3)) #表示从索引为0到索引为3找，顾头不顾尾
print(msg.count('l',0,4)) #从索引为0到索引为4找，顾头不顾尾，找l
#join
user_info='root:x:0:0:addsfg'
l=user_info.split(':') #表示以:做为分隔符，切分成列表
print(':'.join(l)) #表示以:做为分隔符把列表l连接起来
print(''.join(l)) #表示以空做为分隔符把列表l连接起来
print(' '.join(l)) #表示以空格做为分隔符把列表l连接起来
root:x:0:0:addsfg
rootx00addsfg
root x 0 0 addsfg
#center,ljust,rjust,zerofill
print('egno'.center(30,'=')) #30指定总宽度
print('egon'.rjust(30,'='))
print('egon'.ljust(30,'='))
print('egon'.zfill(30)) #z表示zero用0填充
=============egno=============
==========================egon
egon==========================
00000000000000000000000000egon
msg='abc\tdef'
print(msg.expandtabs(3)) #控制制表符的宽度
msg='alex Say Hello'
print(msg.capitalize()) #表示只有首字母大写
print(msg.upper()) #全部大写
print(msg.lower())
print(msg.title()) #每个单词的首字母大写
print(msg.swapcase()) #表示大小写反转
#is 系列
msg = 'alex Say Hello'
print(msg.isupper()) #全部大写才是True
print(msg.islower())
print(msg.istitle())
# #
print(msg.isalpha()) #字符串是由字母组成
print(msg.isalnum()) #字符串是由数字或者字母组成
# 判断数字
age=10
inp=input('>>: ').strip() #表示输入的时候如果有空白就去掉
if inp.isdigit(): #判断输入的字符串是否为数字，并且数字的类型为bytes或者是unicode
    inp=int(inp)
    if inp > age:
        print('ok')
else:
        print('you must input number')
#数字的类型
num1=b'4'#bytes
num2=u'4' #unicode,python3中无需加u就是unicode,就是用户input输入的类型
num3='四' #中文数字
num4='壹'
num5='IV'  #罗马数字
#bytes,unicode，最常用的判断是否为数字
print(num1.isdigit()) True
print(num2.isdigit()) True
print(num3.isdigit()) False
print(num4.isdigit())False
print(num5.isdigit())False
#unicode，只能判断unicode的数字
print(num2.isdecimal()) True
print(num3.isdecimal()) False
print(num4.isdecimal()False
print(num5.isdecimal())False
#unicode,汉子，罗马，除了bytes类型的都可以判断
print(num2.isnumeric()) True
print(num3.isnumeric()) True
print(num4.isnumeric()True
print(num5.isnumeric())True
#
msg='    1'
print(msg.isspace()) #表示是否全部是空格，是就True
msg='aaifbb'
print(msg.isidentifier()) #表示是否包含python的关键字，有就是true，这里的关键字是if

三、列表类型

#定义：[]内多个任意类型的值，逗号分隔
my_girl_friends=['alex','liroutong','linxinru','yangmi',4,5]

#优先掌握的操作
#按索引存取值（正向存取+反向存取）：既可以存也可以取
print(my_girl_friends[2])
print(my_girl_friends[-1])
my_girl_friends[5]='linzhiling'#存值
print(my_girl_friends)
#切片（顾头不顾尾，步长）
print(my_girl_friends[0:2]) #取前两个
print(my_girl_friends[0:4:2]) #取前四个，以2为步长
['alex', 'liroutong']
['alex', 'linxinru']
#长度
print(len(my_girl_friends)) #统计列表里面元素的个数
#成员运算in和notin
print('alex'in my_girl_friends)#元素是否在列表内，在就是True
print(5 in my_girl_friends)
#追加
my_girl_friends.append('6号女友')
print(my_girl_friends)
#删除
del my_girl_friends[0] #最普通的删除，不仅可以删除列表
print(my_girl_friends)
my_girl_friends.remove('alex')
print(my_girl_friends)
print(my_girl_friends.remove('alex')) #remove是单纯的删除，不会返回删除的值，并且是按照值去删除，结果为none
my_girl_friends.pop(-1) #按照索引删除，默认从末尾开始删除
my_girl_friends.pop(1)
print(my_girl_friends)
print(my_girl_friends.pop(-1)) #从列表里面拿走一个值，会返回拿走的值
#常用操作
my_girl_friends=['alex','liroutong','linxinru','yangmi',4,5]
my_girl_friends.insert(0,'sbalex') #在哪个索引后面插入值
my_girl_friends.insert(2,'yh')
my_girl_friends.extend([1,2,3]) #结果为在列表后面插入多个值为1,2,3
print(my_girl_friends)
print(my_girl_friends.count('alex')) #统计alex这个元素有几个
#了解操作
my_girl_friends=['alex','liroutong','linxinru','yangmi',4,5]
my_girl_friends.clear() #清空列表
print(my_girl_friends)
l=my_girl_friends.copy() #表示复制一个列表
print(l)
my_girl_friends.reverse() #反转
print(my_girl_friends)
l=[3,4,-1,2]
l.sort() #从从到大排序
l.sort(reverse=True) #从大到小排序
print(l)
#练习
#队列：先进先出，吃了拉
append,pop
l=[]
l.append('first')
l.append('second')
l.append('third')
print(l)
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
#堆栈：先进后出，吃了吐
l=[]
l.append('first')
l.append('second')
l.append('third')
print(l)
print(l.pop())
print(l.pop())
print(l.pop())
l=[] #也可以写成如下形式
l.insert(0,'first') #表示在索引为0的元素后面插入值first
l.insert(0,'second')
l.insert(0,'third')
print(l)
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

四、元组类型

#元组只能取不能修改，占的内存空间比列表少，是不可变的，列表可以修改里面的元素，而元组不可以，定义好了之后不能修改
#定义方式
ages=(10,12,18,33)#ages=tuple(10,12,18,33)
print(id(ages),type(ages),ages)
#优先掌握的操作
#按索引取值，只能取
#和列表和字符串一样
#切片（顾头不顾尾，步长）
print(ages[0:2])顾头不顾尾
#长度
print(len(ages))
#成员运算in和not in
print(10 in ages)
#其他操作
ages=(10,12,18,33)
print(ages.index(18)) #查看索引
print(ages.count(18)) #统计元素的个数，统计18这个元素出现几次
#while循环列出元素
l=['a','b','c','d','e']
# l='abdcde'
# l=('a','b','c','d','e')
index=0
while index < len(l):
    print(l[index])
    index+=1
#打印字典中的商品名和价格
msg_dir={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
for key in msg_dir: #key会遍历字典的每个key
    print(key,msg_dir[key])
总结：for循环不依赖于索引，会遍历字符串、列表、元组的每个元素，对于字典，会遍历字典的每个key
#range可以模拟打印出索引
for i in range(1,10,2): #顾头不顾尾，结果为1 3 5 7 9
    print(i)
l = ['a', 'b', 'c', 'd', 'e']
for i in range(len(l)): #range可以模拟出打印索引
    print(i,l[i])

#练习，打印商品名、价格、个数，保存到列表中
msg_dir={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods_l=[]#注意此处不能定义为元组，因为元组中不能追加元素，不能进行修改，定义好了只能查看
while True:
    for key in msg_dir:
        print(key,msg_dir[key])
    choice=input('商品名>>:').strip()#.strip()为去除用户输入的空
    if choice not in msg_dir:
        continue
    count=input('个数>>:').strip()
    if count.isdigit(): 判断是否为整数
        goods_l.append((choice,msg_dir[choice],int(count))) #把商品名、价格、购买个数保存到元组中，再把这个元组追加到列表goods_l中，相当于在goods_l列表中追加元素，元素的类型为元组
        print(goods_l)
#for+else  如果循环过程中没有被break或者continue打断，就执行else
for i in range(5):
    if i == 3:
        break
    print(i)
else:
        print('ok')
总结：数字、字符串和元组都是不可变类型，列表是可变类型

五、字典类型

#作用：存多个值，key-value存取，取值速度快
#定义：key必须是不可变类型，value可以是任意类型
d={'a':1}
d={0:1}
d={(1,2,3):1}
d={[1,2,3]:1} #会报错。说明key不可以是可变类型
#优先掌握的操作
#按key存取值，可存可取
info={'name':'egon','age':18,'sex':'male'}
print(info['sex'])
info['hobbies']=['read','music','play','sleep','eat'] #可以根据key进行存值
print(info)
#长度
print(len(info)) #统计元素的个数
#成员运算in和not in
print('name' in info)
print(18 in info) #成员运算时key的运算，而不是value的运算
#删除
print(info.pop('name')) #删除并取值
print(info.pop('name13',None)) #如果没有这个key就返回None
#键keys()，值values(),键值对items()
print(info.keys())
print(info.values())
print(info.items()) #打印键值
for key in info.keys():
    print(key)
for val in info.values():
    print(val)
for item in info.items():
    print(item[0],item[1])
#其他方法
info={'name':'egon','age':18,'sex':'male'}
print(info.get('name123')) #即使没有这个key也不会报错，而是返回None
print(info.get('name123',123)) #如果没有还可以自己指定值为123
print(info.popitem())#删除并取值，删除的是键和值，并且从最后一个删除
#补充两种赋值方式
#一、链式赋值
x=y=z=10
print(id(x),id(y),id(z))
#交换两个变量的值
m=10
n=20
m,n=n,m
print(m,n)
#二、从一个数据类型中解压出我们想要的值
t=(10.3,11.2,12.1,14.3,3.1)
x,y,z,a,b=t
print(x,y,z,a,b) #打印结果为10.3 11.2 12.1 14.3 3.1
x,_,_,_,b=t #用下划线表示不需要打印的变量名
print(x,b)
print(_) #打印出来的是最后一个下划线匹配的变量
x,*_,b=t #也可以用这种形式匹配任意的变量名
print(x,b)
x,*_='hello'
print(x)  只打印x
#总结：字符串、列表、元组都可以用这种方式取出我们想要的值
x,y,z={'a':1,'b':2,'c':3}
print(x,y,z)   #只取key
#常用方法
info={'name':'egon','age':18,'sex':'male'}
for item in info.items():
    print(item) #取出键值放到元组里面
for k,v in info.items(): #用这种方式可以一次取出字典里的键和值
    print(k,v)

#了解
info={'name':'egon','age':18,'sex':'male'}
info_new={'a':1,'age':19}
info.update(info_new) #用info_new来更新info这个字典，当info里面有的就覆盖，没有的就加到后面
print(info) #结果为{'name': 'egon', 'age': 19, 'sex': 'male', 'a': 1}
dic1={}.fromkeys(['name','age','hobbies'],None) #用于初始化一个字典，值为None
print(dic1 )
结果：{'name': None, 'age': None, 'hobbies': None}
info={'name':'egon','age':18,'sex':'male'}
info.setdefault('age',19) #如果字典中已经有key，则不修改，返回原来的值，没有这个key则新增，并返回的是新增的值

六、集合类型

#作用：去重，关系运算
#定义：
#1、每个元素必须是不可变类型，不能是列表，列表是可变类型
#2、没有重复的元素
#3、无序
s={1,2,'a'} #s=set({1,2,'a'})
print(type(s),s)
#长度
s={1,2,'a'}
print(len(s)) #显示元素的个数
#成员运算in和not in
print('a' in s)
for item in s:
    print(item)
#|并集
s1={1,2,3}
s2={3,4.5}
print(s1 | s2)
#&交集
print(s1 & s2)
#-差集
print(s1 -s2) #表示在s1里面不在s2里面

#对称差集
s1={1,2,3}
s2={3,4.5}
print(s1 ^ s2) #去除s1和s2同时存在的
s1={1,2,3}
s2={3,4.5}
print(s1 > s2) #s1是否包含s2
== ，>， >= ，< ，<= ：父集，子集
#其他方法：
s1={1,2,3,4}
s2={3,4,5}
#并集
print(s1.union(s2))
#交集
print(s1.intersection(s2))
#差集
print(s1.difference(s2))
#对称差集
print(s1.symmetric_difference(s2))
print(s1.issuperset(s2)) #s1是s2的父集
print(s2.issubset(s1)) #s2是否是s1的子集
#常用操作
s1={1,2,3,4}
print(s1.pop()) #随机的删除一个元素，并返回删除的结果
print(s1.remove(2)) #删除的时候需要制定元素，并且返回值为None，不会返回删除的结果，并且如果删除的元素不存在，则报错
print(s1.discard('dd')) #单纯的删除，不会返回删除的结果，如果删除的元素不存在，不会报错，返回None
s1.add('b') #添加一个元素
print(s1)
s1={1,2,3}
s2={4,5}
print(s1.isdisjoint(s2)) #如果s1和s2没有交集就返回True
#去重
l=[1,2,3,4,5,3,4]
print(list(set(l))) #去重之后回到列表类型
总结：字典是可变类型，集合是可变的

七、字符编码

就是汉字和数字的对应关系，将不同的语言转换成对应的数字的编码格式
unicode 可以兼容全世界的编码，用2个bytes存的，英文用1个bytes存，所以unicode浪费空间

Python2默认用ASCII编码，Python3默认用UTF-8编码，文件以什么编码存的就要以什么编码去取，这样才不会出现乱码
一个16进制由4位二进制组成，一个字节由8位二进制组成，所以2个16进制
是一个字节
#coding:gbk'
x='上'
print([x])  #可以打印出x这个变量，在内存空间中真正存储的值是什么样的
使用python2打印出来的结果是['\xc9\xcf']，\x代表16进制，c9表示两个16进制，cf表示两个16进制，总共4个16进制，占两个字节
unicode =====encode ======>gbk #将unicode转化成其他编码，gbk是中文的编码
gbk====decode====>unicode #将其他编码转化成unicode编码
#coding:gbk
x='上'
print([x.decode('gbk')]) #将gbk转化成unicode，并且只看unicode中gbk那一列
[u'\u4e0a'] #结果是这个，说明转化成unicode格式
y=x.decode('gbk')
print([y.encode('gbk')]) #将unicode转化为gbk
print([y.encode('utf-8')]) #将unicode转化为utf-8
x=u'上' #直接以unicode格式存储
print(type(x))
print([x.encode('gbk')])
在python2中防止出现乱码，可以在字符串前面加u，定义的时候在内存中就以unicode格式存储，unicode会转化成任意格式的编码，就不会出现乱码
x=u'上'
print(x)
Python3中定义变量时不用加u默认就是unicode格式