八、数据类型与内置方法
一、整型：
======================================基本使用======================================
1、用途: 记录年龄\等级\各种号码
2、定义方式:
age=18 # age=int(18)
x=int('123') #只能将纯数字的字符串转换成整型
print(type(x))
print(int(3.7))
3、常用操作+内置的方法
赋值\比较\算术
======================================该类型总结====================================
存一个值
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
print(hash(10))
print(hash([1,2,3]))
二、浮点类型：
======================================基本使用======================================
1、用途: 记录身高\体重\薪资
2、定义方式
salary=1.3 #salary=float(1.3)
x=float('3.1')
print(x,type(x))
3、常用操作+内置的方法
赋值\比较\算术
======================================该类型总结====================================
存一个值
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
x=3.1
print(id(x))
x=3.2
print(id(x))
了解:
复数
x=1-2j
print(x,type(x))
print(x.real)
print(x.imag)
长整型
其他进制=>十进制
十进制: 0-9
11 = 1*10^1 + 1*10^0
二进制: 0 1
11 = 1*2^1 + 1*2^0
八进制: 0-7
11 = 1*8^1+1*8^0
十六进制:0-9 A-F
11 = 1*16^1+1*16^0
十进制=>其他进制
print(bin(13)) # 十进制=>二进制
print(oct(13)) # 十进制=>八进制
print(hex(13)) # 十进制=>十六进制
三、字符串类型：
# ======================================基本使用======================================
# 1、用途:记录描述性质的特征,比如名字\地址\性别
# 2、定义方式:在单引号\双引号\三引号内包含的一串字符
msg='aaa"bbb"' #msg=str(...)
可以将任意类型转换成字符串
str(1)
str(1.3)
x=str([1,2,3])
print(x,type(x))
3、常用操作+内置的方法
优先掌握的操作（*****）
1.按索引取值（正向取+反向取）：只能取不能改 msg='hello world' print(msg[0]) print(msg[5]) print(msg[len(msg)-1]) print(msg[-1])
#2、切片(顾头不顾尾，步长): 想要从一个大字符串中切出一个小字符串 msg='hello world' print(msg[0:5]) print(msg) print(msg[0:5:2]) #了解 msg='hello world' print(msg[-1:-5:1]) print(msg[-1:-5:-1]) print(msg[0:5:1]) print(msg[-1::-1]) #掌握
#3、长度len msg='你好啊a' print(len(msg))
#4、成员运算in和not in msg='yangyuanhu 老师是一个非常虎的老师' print('yangyuanhu' in msg) print('虎' not in msg) print(not '虎' in msg)
#5、移除字符串左右两边的字符strip:默认去空格 pwd=' 1 23 ' res=pwd.strip(' ') print(res) pwd=input('>>: ').strip() #pwd='123' if pwd == '123': print('密码输入正确') pwd='******12*3****' print(pwd.strip('*')) pwd='****/&^**123**^*/*&' print(pwd.strip('*/&^')) print(pwd.strip('*/&')) #^**123**^
#6、切分split:针对有规律字符串按照某个字符切成列表 info='yyhdsb|18|female' li=info.split('|',1) print(li)
#7、循环 msg='hello' for item in msg: print(item)
# ======================================该类型总结====================================
# 存一个值
# 有序
# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
# s1='hello'
# print(id(s1))
# s1='world'
# print(id(s1))
4、需要掌握的操作(****)
1、strip,lstrip,rstrip print('****egon***'.strip('*')) print('****egon***'.lstrip('*')) print('****egon***'.rstrip('*')) 2、lower,upper print('AAAbbbb'.lower()) print('AAAbbbb'.upper())
3、startswith,endswith print('alex is sb'.startswith('alex')) print('alex is sb'.endswith('sb'))
4、format的三种玩法 print('my name is %s my age is %s' %('egon',18)) print('my name is %s my age is %s' %(18,'egon')) print('my name is {name} my age is {age} '.format(age=18,name='egon')) 了解 print('my name is {} my age is {} '.format(18,'egon')) print('my name is {0} my age is {1} '.format(18,'egon')) print('my name is {1} my age is {0} '.format(18,'egon'))
5、split,rsplit msg='a:b:c:d:e' print(msg.split(':',1)) print(msg.rsplit(':',1))
6、join msg='a:b:c:d:e' list1=msg.split(':') msg1=':'.join(list1) print(msg1) info='egon:123:male' list1=info.split(':') print(list1) print(':'.join(list1))
7、replace msg='alex is alex alex is hahahaha' print(msg.replace('alex','SB',1))
8、isdigit print('123'.isdigit()) # 只能判断纯数字的字符串 print('12.3'.isdigit()) age_of_db=30 inp_age=input('>>>: ').strip() if inp_age.isdigit(): inp_age=int(inp_age) if inp_age > age_of_db: print('too big') elif inp_age < age_of_db: print('too small') else: print('you got it')
5、了解的操作（**）
1、find,rfind,index,rindex,count msg='hello worldaa' print(msg.index('wo')) print(msg.index('wo',0,3)) print(msg.find('wo',0,3)) print(msg.find('xxxxxxx')) print(msg.index('xxxxxxx')) print(msg.count('l'))
2、center,ljust,rjust,zfill name=input('>>: ').strip() print('egon'.center(50,'=')) print(('%s' %name).center(50,'-')) print('egon'.ljust(50,'=')) print('egon'.rjust(50,'=')) print('egon'.zfill(50))
3、expandtabs print('hello\tworld'.expandtabs(5))
4、captalize,swapcase,title print('hello world'.capitalize()) print('Hello world'.swapcase()) print('Hello world'.title())
5、is数字系列 num1=b'4' #bytes num2=u'4' #unicode,python3中无需加u就是unicode num3='四' #中文数字 num4='Ⅳ' #罗马数字 isdigit: bytes,str print(num1.isdigit()) print(num2.isdigit()) print(num3.isdigit()) print(num4.isdigit()) isdecimal:str print(num2.isdecimal()) print(num3.isdecimal()) print(num4.isdecimal()) isnumberic:str,中文\罗马 print(num2.isnumeric()) print(num3.isnumeric()) print(num4.isnumeric())
6、is其他 print('aaasdfaA'.isalpha()) # 纯字母组成的字符串 print('aaasdfaA123'.isalnum()) # 字母或数字组成 print('aaasdfaA'.isalnum()) # 字母或数字组成 print('123'.isalnum()) print(' '.isspace()) print(' 12'.isspace())
四、列表类型：
# ======================================基本使用======================================
# 1、用途:记录多个值,比如人的多个爱好
# 2、定义方式: 在[]内用逗号分隔开多个任意类型的值
li=[1,2,3] # li=list([1,2,3])
# x=list('hello')
# x=list({'a':1,'b':2,'c':3})
# print(x)
3、常用操作+内置的方法
优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取 li=['a','b','c','d'] print(li[-1]) li[-1]='D' print(li) # li[4]='e' del li[0] print(li)
2、切片(顾头不顾尾，步长) li=['a','b','c','d'] print(li[0:3])
3、长度 li=['a','b','c','d'] print(len(li))
4、成员运算in和not in users=['egon','lxx','yxx','cxxx',[1,2,3]] print('lxx' in users) print([1,2,3] in users) print(1 in users)
5、追加 li=['a','b','c','d'] print(id(li)) li.append('e') li.append([1,2,3]) print(li,id(li))
6、删除 li=['a','b','c','d'] 按照元素值去单纯地删除某个元素 del li[1] res=li.remove('c') print(li) print(res) 按照元素的索引去删除某个元素并且拿到该元素作为返回值 res=li.pop(1) print(li) print(res)
7、循环 li=['a','b','c','d'] for item in li: print(item)
# ======================================该类型总结====================================
# 存多个值
# 有序
# 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
# print(hash([1,2,3]))
4.需要掌握的操作
1.统计元素在列表出现的次数count li=['a','b','c','d','c','e'] print(li.count('c'))
2.将一个列表拆分后加入到另一个列表中extend, li=['a','b','c','d','c','e'] li.extend([1,2,3]) li.append([1,2,3])#append是整体加入到列表中 print(li)
3.取到制定元素在列表所对应的索引index,可设置范围 li=['a','b','c','d','c','e'] print(li.index('z')) print(li.index('b')) print(li.index('d',0,3))
4.在制定的索引位置添加一个元素到列表中insert li=['a','b','c','d','c','e'] li.insert(1,'egon') print(li)
5.把列表从尾到头，从新排列reverse li=['name','age','sex'] li=[3,1,9,11] li.reverse() print(li)
6.给列表从左到右的排序sort(数字按从小到大，字母元素安照首字母大小排列） li=[3,1,9,11] li=['name','age','sex','hobbies'] li.sort() print(li)
五、元组类型：
什么是元组：元组就是一个不可变的列表
1.用途：用于存放多个值，当存放的多个值只有读的需求，没有改的需求时用元组最合适
2.定义方式：在（）内用逗号隔开存放多个任意类型的值
t=(1,3.1,'qqq',[1,2,3],{'k1':2.'k2':3})
当元组只存一个值的时候，最后要加一个逗号
t=('hello',)
3.常用的操作+内置方法
优先掌握的操作：
#优先掌握的操作： #1、按索引取值(正向取+反向取)：只能取 # t=('a','b',1) # t[0]=111
#2、切片(顾头不顾尾，步长) # t=('h','e','l','l','o') # res=t[1:3] # print(res) # print(t)
#3、长度 # t=('h','e','l','l','o') # print(len(t))
#4、成员运算in和not in # t=('h','e','l','l','o') # print('h' in t)
#5、循环 # t=('h','e','l','l','o') # for item in t: # print(item)
#按值取索引号和按值计算元素次数 # t=('a','b','a') # print(t.index('a')) # t.index('xxx') # print(t.count('a'))
# ======================================该类型总结====================================
# 存多个值
# 有序
# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
# t=(1,'a',['x','y','z'])
# print(id(t[2]))
# print(id(t)) # t[2][0]='X' # print(t) # print(id(t)) # print(id(t[2])) # list1=['a','b','c'] # print(id(list1[0])) # print(id(list1[1])) # print(id(list1[2])) # # print('='*50) # list1[1]='B' # print(id(list1[0])) # print(id(list1[1])) # print(id(list1[2]))
六、字典类型：
# ======================================基本使用======================================
# 1、用途: 用来存放多个(不同种类的)值
#
# 2、定义方式: 在{}内用逗号分隔开多个key:value的元素,其中value可以是任意数据类型,而key的功能通常是用来
# 描述value的,所以key通常是字符串类型,但其实key必须是不可变的类型(int\float\str\tuple)
# d={0:'x',1.3:'y','k1':'z',(1,2,3):'aaa'} # d=dict(....)
# print(d[(1, 2, 3)])
# d1={[1,2,3]:'aaaaa'}
#字典的几种赋值方法： # d=dict([('k1',1),('k2',2),('k3',3)]) # print(d) # l=[('k1',1),('k2',2),('k3',3)] # d={} # for t in l: #t=('k1',1) # k,v=t # # print(k,v) # d[k]=v # print(d) # # # d=dict(l) # print(d) # d=dict(x=1,y=2,z=3) # print(d)
# 3、常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取 # d={'x':1} # print(d['x']) # print(id(d)) # d['x']=1111 # print(d) # print(id(d)) # d['y']=2222 # print(d)
#2、长度len # d={'x':1,'y':2,'z':3} # print(len(d))
#3、成员运算in和not in # d={'x':1,'y':2,'z':3} # print(1 in d) # print('x ' in d)
#4、删除 # d={'x':1,'y':2,'z':3} # del d['y'] # print(d) # res=d.pop('y') # print(d) # print(res) # res=d.popitem() # print(res)
#5、键keys()，值values()，键值对items() # d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]} # # print(d.keys()) # print(list(d.keys())) # # # print(d.values()) # print(list(d.values())) # # print(d.items()) # print(list(d.items()))
#6、循环 # for k in d.keys(): # print(k) # for k in d: # print(k) # for v in d.values(): # print(v) # for k,v in d.items(): #k,v=('name', 'egon') # print(k,v)
# 需要掌握的操作
# get方法 # d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]} # v=d.get('namexxxxxxx') # print(v) # v1=d['namexxxxxxxxxxx'] # print(v1)
#update方法 # d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]} # d.update({'x':1,'name':"EGON"}) # print(d)
# fromkeys:需求是快速新造出一个字典,value的初始值全都为None,而key是来自于一个列表 # keys=['name','age','sex'] # # d={} # # for k in keys: # # d[k]=None # # d={}.fromkeys(keys,None) # print(d)
# setdefault # d={"x":1,"y":2} # 按照默认的操作形式 # d['x']=1111 # key存在则修改 # d['z']=1111 #key不存在则新增 # 按照setdefault的形式 # d={"x":1,"y":2} # res=d.setdefault('x',11111) # 在key存在的情况下不修改值,会返回原值 # print(d) # print(res) # res=d.setdefault('z',11111) # 在key不存在的情况下会新增值,会返回新增的值 # print(d) # print(res)
# ======================================该类型总结====================================
# 存多个值
# 无序
# dict可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash
七、集合类型：
1. 什么是集合
在{}内用逗号分隔开多个值,集合的特点:
1. 每个值必须是不可变类型
2. 集合无序
3. 集合内元素不能重复
2. 为何要用集合
1. 用于做关系运算
2. 去重
3. 如何用集合
# s={1,1.3,'aa',[1,2,]} # s={1,1.3,'aa'} # print(s) # s={1,1,1,1,1,1,1,2} #s=set(....) # print(type(s)) # print(s) # d={'x':1,'x':2,'x':3} # print(d) # res=set('hello') # res=set([1,2,['a','b']]) # print(res)
# pythons=['egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯'] # linuxs=['欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb'] # l=[] # # for stu in pythons: # if stu in linuxs: # l.append(stu) # print(l)
# 集合的第一大用途: 关系运算
pythons={'egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯'}
linuxs={'欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb'}
# 1 求同时报名两门课程的学生姓名:交集 # print(pythons & linuxs) # print(pythons.intersection(linuxs)) # pythons=pythons & linuxs # print(pythons) #{'李铜蛋', '艾里克斯'} # pythons.intersection_update(linuxs) #pythons=pythons.intersection(linuxs) # print(pythons) #{'艾里克斯', '李铜蛋'}
# 2 求报名老男孩学校课程的所有学生姓名:并集 # print(pythons | linuxs) # print(pythons.union(linuxs))
# 3 求只报名python课程的学生姓名: 差集 # print(pythons - linuxs) # print(pythons.difference(linuxs)) # print(linuxs - pythons) #求只报名linux课程的学生姓名 # print(linuxs.difference(pythons))
# 4 求没有同时报名两门课程的学生姓名: 对称差集 # print((pythons - linuxs) | (linuxs - pythons)) # print(pythons ^ linuxs) # print(pythons.symmetric_difference(linuxs))
# 5 父子集:指的是一种包含与被包含的关系 # s1={1,2,3} # s2={1,2} # print(s1 >= s2) # print(s1.issuperset(s2)) # print(s2.issubset(s1))
# 情况一: # print(s1 > s2) #>号代表s1是包含s2的,称之为s1为s2的父集 # print(s2 < s1)
# 情况二: # s1={1,2,3} # s2={1,2,3} # print(s1 == s2) #s1如果等于s2,也可以称为s1是s2的父集合
# 综上: # s1 >= s2 就可以称为s1是s2的父集 # s3={1,2,3} # s4={3,2,1} # print(s3 == s4) # s5={1,2,3} # s6={1,2,3} # print(s5 >= s6) # print(s6 >= s5)
# 集合的第二大用途:去重
# 集合去重的局限性:
# 1. 会打乱原值的顺序
# 2. 只能针对不可变的值去重
# stus=['egon','lxx','lxx','alex','alex','yxx'] # new_l=list(set(stus)) # print(new_l) # # old_l=[1,[1,2],[1,2]] # set(old_l) # l=[ # {'name':'egon','age':18,'sex':'male'}, # {'name':'alex','age':73,'sex':'male'}, # {'name':'egon','age':20,'sex':'female'}, # {'name':'egon','age':18,'sex':'male'}, # {'name':'egon','age':18,'sex':'male'}, ] # new_l=[] # for dic in l: # if dic not in new_l: # new_l.append(dic) # print(new_l
# 需要掌握的操作: # s1={1,2,3} # s1.update({3,4,5}) # print(s1) # print(s1.pop()) # print(s1) # s1.remove(2) # print(s1) # s1={1,2,3} # print(id(s1)) # s1.add(4) # print(s1) # print(id(s1)) # s1={1,2,3} # s1.discard(4) # s1.remove(4) # print(s1) # s1={1,2,3} # s2={4,5} # print(s1.isdisjoint(s2))
# ======================================该类型总结====================================
# 存多个值
# 无序
# 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
