数据类型及常用方法

可变类型与不可变类型

　1、可变类型

　　　　值改变，id不变，说明是直接改变原值，是可变类型

　2、不可变类型

　　　　值改变，id也跟着改变，说明是产生了新的值，是不可变类型

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

ps:整型,浮点型:存一个值,不可变

#整型
 #用途:记录电话号码,年龄,QQ号等纯数字
 #定义方式　

age=18 #age=int(18)
print(type(age))
int('abadf') #报错
int('10.1') #报错
int('101') #int只能将字符串中包含纯数字转成整型

# 十进制转成其他进制
print(bin(12))
print(oct(12)) #12 =>1*(8**1) + 2*(8**0)
print(hex(16))

# 进制转换（了解**）
# 其他进制转成十进制
print(int(10,2))
print(int(10,8))
print(int(10,16))

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

salary=3000.3 #本质salary=float(3000.3)

  

字符串(str)

ps:字符串类型:只能够存一个值,有序且不可变

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

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

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 # 判断字符串中包含的是否为纯数字

1.strip,lstrip,rstrip方法:方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
    ps:该方法只能删除开头或是结尾的字符,不能删除中间部分的字符.
name = '*egon**'
ptint(name.strip('*')) ##结果:egon
ptint(name.lstrip('*')) ##结果:egon**
ptint(name.rstrip('*')) ##结果:**egon

2.lower,upper方法:转换字符串中所有大小写字符。
name='Egon'

print(name.lower()) ##结果:egon

print(name.upper()) ##结果:EGON

3.startswith,endswith方法:用于判断字符串是否以指定开头/后缀结尾，如果以指定开头/后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
name='alex_SB'
print(name.endswith('SB')) ##结果:True 
print(name.startswith('ex')) ##结果:Flase

4.format()方法:可以接受不限个参数，位置可以不按顺序。
res='{} {} {}'.format('egon',18,'male') ##结果:egon 18 male  ps:输出默认位置
res='{1} {0} {1}'.format('egon',18,'male') ##结果:18 egon 18    ps:输出指定位置
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18) ##结果:egon 18 male    ps:输出指定位置

5.split()方法:通过指定分隔符对字符串进行切片
# 例题:
# 将以下数据存储为字典类型
# 数据：info = "name:Owen|age:18|gender:男"
# 结果：{'name': 'Owen', 'age': 18, 'gender': '男'}
info = "name:Owen|age:18|gender:男"
infos = info.split('|')
info_dic = {}
for i in infos:
    k,v = i.split(':')
    info_dic = k[v]
print(info_dic)

6.join()方法:用于将序列中的元素以指定的字符连接生成一个新的字符串。
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串
输出结果:egonsayhello

7.replace()方法:把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
输出结果:SB say :i have one tesla,my name is alex

8.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数字系列

#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\thello'
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())

 

列表(list)

ps:列表类型:能存多个值,有序,可变 

# 1 用途：存放多个值，可以根据索引存取值

# 2 定义方式：在[]内用逗号分割开多个任意类型的值

  l=['egon','lxx','yxx'] # l=list(['egon','lxx','yxx'])
　l1=list('hello') #list就相当于调用了一个for循环依次取出'hello'的值放入列表
　print(l1)
　l2=list({'x':1,'y':2,'z':3})
　print(l2)
　list(10000) # 报错

# 3 常用操作+内置的方法

#优先掌握的操作：

l=['egon','lxx','yxx']
print(l[0])
l[0]='EGON'
print(l)
print(l[-1])
print(l[3])
l[0]='EGON' # 只能根据已经存在的索引去改值
l[3]='xxxxxxxx' #如果索引不存在直接报错

#2、切片(顾头不顾尾，步长)
l=['egon','lxx','yxx',444,555,66666]
print(l[0:5])
print(l[0:5:2])
print(l[::-1])

#3、长度
l=['egon','lxx','yxx',444,555,66666,[1,2,3]]
print(len(l))

#4、成员运算in和not in
l=['egon','lxx','yxx',444,555,66666,[1,2,3]]
print('lxx' in l)
print(444 in l)

#5、追加
l=['egon','lxx','yxx']
l.append(44444)
l.append(55555)
print(l)

#6、往指定索引前插入值
l=['egon','lxx','yxx']
l.insert(0,11111)
print(l)
l.insert(2,2222222)
print(l)
#利用insert往最后追加值
l = [1,2,3,4,5]
l.insert(len(l),6)
print(l)

# 一次性添加多个元素
l = ['jason','nick']
l.extend(['tank','sean'])

#7、删除
l=['egon','lxx','yxx']

# 单纯的删除值：
# 方式1：
del l[1] # 通用的
print(l)

# 方式2：
res=l.remove('lxx') # 指定要删除的值，返回是None
print(l,res)

# 从列表中拿走一个值
res=l.pop(-1) # 按照索引删除值(默认是从末尾删除)，返回删除的那个值
print(l,res)

#8、循环
l=['egon','lxx','yxx']
for item in l:
    print(item)

 

# 需要掌握的操作

l=['egon','egon','lxx','yxx',444,555,66666]
print(l.count('egon'))
print(l.index('egon'))
print(l.index('yxx',0,1))
l.clear()

items=['a','b','c']
items='hello'
for item in items:
l.append(item)
l.extend(items)
print(l)

l=['egon','egon','lxx','yxx',444,555,66666]
l.reverse()
print(l)

nums=[3,-1,9,8,11]
nums.sort(reverse=True)
print(nums)items=[1,'a','b',2items.sort()

 

 队列,堆栈

l=['a','b','c']
print(id(l))
l.append('d')
print(id(l))


# 队列：先进先出
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())

 

元组tuple

ps:元组类型:可以存多个值,有序,不可变

与列表类似可以存储多个值,但是不同的是元组本身不能被修改

# 1 用途:记录多个值,当多个值没有改的需求,此时用元组更合适

# 2 定义方式:在()内部用逗号隔开多个任意类型的值

 

t = (1, 2 ,3 ,'a' ,'b' , ('a','b'), [1,2])  # t = tuple((1, 2 ,3 ,'a' ,'b' , ('a','b'), [1,2]))
print(type(t))  # <class 'tuple'>
# t0 = tuple(1) # int类型不是可迭代对象 所以报错
# print(t0)

  

ps:可迭代对象:

实现了__inter__方法的对象就叫做可迭代对象”，__inter__方法的作用就是返回一个迭代器对象。直观理解就是能用for循环进行迭代的对象就是可迭代对象。比如：字符串，列表，元祖，字典，集合等等，都是可迭代对象。

t1 = tuple('hello') print(t1)  # ('h', 'e', 'l', 'l', 'o')'''

# 3 常用操作+内置方法

#优先掌握的操作:#1、按索引取值(正向取+反向取)：只能取
t=('egon',123,['a','b'])
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))

t[2][0]='A'
print('='*50)
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
t[0]='EGON'

t[2]='xxxx'
t[2][0]='A'
print(t) # ('egon', 123, ['A', 'b'])
ps:这年头谁还不是个灵魂画师
#2、切片(顾头不顾尾，步长)
t=(1,2,3,4,5)
print(t[0:3])  #(1, 2, 3)
print(t)  #(1,2,3,4,5) 原值不变

#3、长度
len()

#4、成员运算in和not in

#5、循环
for item in ('a','b','c'):
    print(item)

# 需要掌握的操作
t=('a','b','c','a')
print(t.count('a'))  # 2 统计a出现的次数
print(t.index('a',1,10)) 
print(t.index('xxx',1,10))  # t中没有'xxx' 报错

　　

 

字典dict

ps:字典类型: 能存多个值,无序,可变

# 1 用途：记录多个值，每一个值都对应的key用来描述value的作用
# 2 定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型

dic={0:'aaa',1:'bbb',2:'cccc'} # dic=dict({0:'aaa',1:'bbb',2:'cccc'})
print(dic,type(dic))
print(dic[0])

dic={[1,2]:'aaa'}
dic={(1,2):'aaa'}
print(dic[(1,2)])

# 用法一：
dic=dict(x=1,y=2,z=3)
print(dic)

# 用法二：
userinfo=[
['name','egon'],
['age',18],
['sex','male']
]
d={}
for k,v in userinfo: # k,v=['name', 'egon']
# print(k,v)
d[k]=v
print(d)

# d=dict(userinfo)
# print(d)

 

# 3 常用操作+内置的方法

#优先掌握的操作：
#1、按key存取值：可存可取
dic={'name':'egon'}
print(dic['name'])
dic['name']='EGON'
print(dic)
dic['age']=18
print(dic)

#2、长度len
dic={'name':'egon','age':18,'name':'EGON','name':'XXXX'}
print(dic)
print(len(dic))

#3、成员运算in和not in:字典的成员运算判断的是key
dic={'name':'egon','age':18,}
print(18 in dic)
print('age' in dic)

#4、删除
dic={'name':'egon','age':18,}
# 通用
del dic['name']
print(dic)
del dic['xxx'] ##key不存在则报错


res=dic.pop('age') #删除key对应的value,并返回value
print(dic)
print(res) #
dic.pop('xxx') #key不存在则报错

res=dic.popitem()
print(dic)
print(res)

#5、键keys()，值values()，键值对items() 注意python2与python3之间的区别
dic={'name':'egon','age':18,}
print(dic.keys())
l=[]
for k in dic.keys():
l.append(k)
print(l)
print(list(dic.keys()))
print(dic.values())
print(list(dic.values()))
print(dic.items())
print(list(dic.items()))

 

#6、循环
dic={'name':'egon','age':18,'sex':'male'}

for k in dic.keys():
print(k,dic[k])

for k in dic:
print(k,dic[k])

for v in dic.values():
print(v)

for k,v in dic.items():
print(k,v)

#8 dic.get()
dic={'name':'egon','age':18,'sex':'male'}
dic['xxx']
v=dic.get('name')
print(v)

v=dic.get('xxx')
print(v)

# 需要掌握的操作

#dic.fromkeys()的用法:
l=['name','age','sex']
dic={'name':None,'age':None,'sex':None}
dic={}
for k in l:
dic[k]=None
print(dic)

dic=dic.fromkeys(l,None)
print(dic)

 
old_dic={'name':'egon','age':18,'sex':'male'}
new_dic={'name':'EGON','x':1,'y':2}
old_dic.update(new_dic)
print(old_dic)

# setdefault:有则不动/返回原值,无则添加/返回新值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON') # 字典中已经存在key则不修改,返回已经存在的key对应的value
print(dic)
print(res)

res=dic.setdefault('sex','male') # 字典不存在key则添加"sex":"male",返回新的value
print(dic)
print(res)

练习

# 练习1:
nums=[11,22,33,44,55,66,77,88,99,90]
dic={
'k1':[],
'k2':[]
}
for num in nums:
if num > 66:
dic['k1'].append(num)
else:
dic['k2'].append(num)
print(dic)

# 练习2:
s='hello alex alex say hello sb sb'
words=s.split()
dic={}
# print(words)
for word in words:
if word in dic:
dic[word]+=1
else:
dic[word]=1
print(dic)

s='hello alex alex say hello sb sb'
words=s.split()
dic={}
for word in words: # word="hello"
dic.setdefault(word,words.count(word)) #{'hello':2,"alex":2,"say":1,}
print(dic)

 

集合set

ps:集合类型: 能存多个子,无序可变

# 1 用途: 关系运算,去重
# 2 定义方式: 在{}内用逗号分开个的多个值
# 集合的三大特性:
# 2.1 每一个值都必须是不可变类型
# 2.2 元素不能重复
# 2.3 集合内元素无序

s={1,3.1,'aa',(1,23),} # s=set({1,3.1,'aa',(1,23),})
print(s,type(s))

s={1,1,1,1,1,1,1,1,1,2,3}
print(s)

s={'a','b','c'}
s[0]

s=set('hello')
print(s)
print(set(['a','b','c',[1,2]]))

 

# 3 常用操作+内置的方法

pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'}
linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'}
# 取及报名python课程又报名linux课程的学员:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

# 取所有报名老男孩课程的学员:并集
print(pythons | linuxs)
print(pythons.union(linuxs))

# 取只报名python课程的学员: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))

# 取只报名linux课程的学员: 差集
print(linuxs - pythons)
print(linuxs.difference(pythons))

# 取没有同时报名两门课程的学员:对称差集
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

# 是否相等
s1={1,2,3}
s2={3,1,2}
print(s1 == s2)

# 父集:一个集合是包含另外一个集合
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))

s1={1,2,3}
s2={1,2,4}
print(s1 >= s2)

# 子集
s1={1,2,3}
s2={1,2}
print(s2 <= s1)
print(s2.issubset(s1))

# 需要掌握操作
s1={1,2,3}
s1.update({3,4,5})
print(s1)

s1={1,2,3}
res=s1.pop()
print(res)

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)

s1={1,2,3}
s1.add(4)
print(s1)

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错


s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s={1,2,3}
print(id(s))
s.add(4)
print(id(s))

# 集合去重
# 局限性
#1、无法保证原数据类型的顺序
#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重

names=['alex','egon','alex','alex','egon','lxx']
s=set(names)
print(s)
l=list(s)
print(l)

stus_info=[
{'name':'egon','age':18},
{'name':'alex','age':73},
{'name':'oldboy','age':84},
{'name': 'egon', 'age': 18},
{'name': 'egon', 'age': 18},
{'name': 'egon', 'age': 18},
{'name': 'oldboy', 'age': 84},

]
# set(stus_info) # 报错
l=[]
for info in stus_info:
if info not in l:
l.append(info)

# print(l)
stus_info=l
print(stus_info)

 

ps: 关于有序无序:主要按照该类型是否能够按照索引取值

 

来源：https://www.cnblogs.com/linxidong/p/11126501.html