数据类型

1.数字类型

#一：基本使用
# 1 int用途:年龄 号码 等级...

# 2 定义方式
age=10 #age=int(10)
# x=int('1111') # int只能将纯数字的字符串转成十进制的整型
# print(type(x))

# 3 常用操作+内置的方法
#算数运算,比较运算



#二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
# age=10
# age

# 2 有序or无序
#    没有有序无序这么一说

# 3 可变or不可变
#可变不可变类型总结:
#     可变指的是改变原值,即在原值基础上进行修改
#     可变类型的底层原理:在id不变的情况下,值可以改变
#     不可变类型的底层原理:值改变,id也跟着变
#int是不可变数据类型
# age=10
# print(id(age))
# age=11
# print(id(age))


# 了解(**):
# 长整型Long,只有在python2中才有长整型号
# 复数complex
# x=1-2j
# print(x.real)
# print(x.imag)
# print(type(x))


#一：基本使用
# 1 用途:薪资 身高 体重
#
# 2 定义方式
salary=3.1 #salary=float(3.1)
n=float('3.1')

# 3 常用操作
#算数运算 比较运算

# #二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
#
# 2 有序or无序
#    没有有序无序这么一说

# 3 可变or不可变
# float是不可变类型
# x=3.1
# print(id(x))
# x=3.2
# print(id(x))

2.字符串类型

#一：基本使用
# 1 用途: 描述性质的数据,比如人的名字,单个爱好,地址
#
# 2 定义方式
# name='egon' #name=str('egon')
# x=str(1)
# y=str(1.1)
# z=str([1,2,3])
# n=str({'a':1})
# print(type(x))
# print(type(y))
# print(type(z))
# print(type(n))

# 3 常用操作+内置的方法
#优先掌握的操作(*****)：
#1、按索引取值(正向取+反向取) ：只能取
msg='hello world'
# print(msg[5])         #打印第6个字母(为字符串格式)
# print(msg[-1])        #打印倒数第一个字母(为字符串格式)
# msg[2]='A'            #会报错,只能取

#2、切片(顾头不顾尾，步长)
# msg='hello world'
# print(msg[1:5],type(msg[1:5]))           #打印ello(第2个到第5个,顾头不顾尾)
# print(msg[6:-1])
# print(msg[6:11])
# print(msg[6:])                           #不写尾就是取完
# print(msg[6::2])                         #去完 步长为2
# 了解(**)

# print(msg[0:])
# print(msg[::-1])
# msg='hello world'
# print(msg[-3:-6:-1])
# print(msg[6:9:-1])

#3、长度len
# msg='hello world'
# print(len(msg))

#4、成员运算in和not in
# print('SB' in  'my name is alex,alex is SB')
# print('alex' in  'my name is alex,alex is SB')
# print('egon' not in  'my name is alex,alex is SB')    #判断'egon'是否在后面的字符串中
# print('egon' in  'my name is alex,alex is SB')        #判断'egon'是否在后面的字符串中
# print(not 'egon' in  'my name is alex,alex is SB')


#5、移除空白strip
# name='  e gon        '
# print(name.strip(' '))
# print(name.strip())          #什么都不写默认去除两边
# name='****A*e*gon****'
# print(name.strip('*'))

# name='****egon****'
# print(name.lstrip('*'))
# print(name.rstrip('*'))
# pwd=input('>>: ').strip() #pwd='123  '            #strip()的用法
# if pwd == '123':
#     print('login successful')


# msg='cccabcdefgccccc'
#          'c'
# print(msg.strip('c'))

# print('*-=egon *&^'.strip('-= *&^'))

#6、切分split
# msg='egon:18:male:180:160'            #按照某种字符 ( 如 :  空格  字母 ) 切分成 列表 中的多个值
# l=msg.split(':')
# print(l)
# print(l[3])
#7、循环
# msg='hello world'
# for x in msg:                         #for循环
#     print(x)

# 需要掌握的操作(****)
#1、strip,lstrip,rstrip                  #去空格

#2、lower,upper
# name='EoN'                            #改大写小写
# print(name.lower())

# name='egonN'
# print(name.upper())

#3、startswith,endswith
# print('alex is SB'.startswith('alex'))            #查看字符串以什么开头或以什么结尾
# print('alex is SB'.endswith('B'))

#4、format的三种玩法
# print('my name is %s my age is %s' %('egon',18))
# print('my name is {name} my age is {age}'.format(age=18,name='egon')) # 可以打破位置的限制,但仍能指名道姓地为指定的参数传值

# print('my name is {} my age is {}'.format('egon',18))
# print('my name is {0} my age is {1} {1} {1} {1}'.format('egon',18))

#5、split,rsplit
# info='egon:18:male'               #按:的切分,1表示按第一个切分  rsplit从右往左切
# print(info.split(':',1))
# print(info.split(':',1)) #['egon','18:male']
# print(info.rsplit(':',1)) #['egon:18','male']

#6、join:只能将元素全为字符串的列表拼成一个大的字符串
# info='egon:18:male'
# l=info.split(':')
# print(l)
# new_info='-'.join(l)
# print(new_info)

# num=['a','b','c']
# ':'.join(num) #'a'+':'+'b'+':'+'c'

# num=[1,2,'c']
# ':'.join(num) #1+':'+2+':'+'c'

#7、replace
# msg='my name is wupeiqi,wupeiqi is SB'
# print(msg.replace('wupeiqi','Pig',1))            #1指的是换的次数
# print(msg)

#8、isdigit
# print('111.1'.isdigit())                  #是否字符串内全是数字
# print('1111'.isdigit())

# AGE=73
# age=input('>>: ').strip() #age='asdfasdf'
# if age.isdigit():
#     age=int(age)
#     if age > AGE:
#         print('too big')
#     elif age < AGE:
#         print('too small')
#     else:
#         print('you got it')
# else:
#     print('必须输入数字啊傻叉')

# 其他操作（了解即可）(**)
#1、find,rfind,index,rindex,count
# msg='my name is alex,alex is hahaha'
# print(msg.find('alex'))
# print(msg.find('SB')) #找不到会返回-1

# print(msg.index('alex'))
# print(msg.index('SB')) # 找不到index会报错

# print(msg.find('alex',0,3))

# print(msg.count('alex'))
# print(msg.count('alex',0,15))

#2、center,ljust,rjust,zfill
# print('info egon'.center(50,'-'))
# print('info egon'.ljust(50,'-'))
# print('info egon'.rjust(50,'-'))
# print('info egon'.zfill(50))

#3、expandtabs
# print('a	b	c'.expandtabs(1))

#4、captalize,swapcase,title
# print('my name is egon'.capitalize())
# print('my Name Is egon'.swapcase())
# print('my name is egon'.title())

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

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

#isdecimal():unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())

#isnumberic;unicode,中文,罗马
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())

#6、is其他
# print('abasdf123123'.isalnum())
# print('asdfasdf'.isalpha())
# print('egon'.islower())
# print('ABC'.isupper())

# print('     '.isspace())
# print('My Name Is Egon'.istitle())


# #二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
#
# 2 有序or无序
# 有序

# 3 可变or不可变
# 不可变

# name='egon'
# print(id(name))
# name='alex'
# print(id(name))

3.列表类型

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

#定义：[]内可以有多个任意类型的值，逗号分隔
# my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
#
# l=list('hello') # list内只能跟能够被for循环遍历的数据类型
# print(l)
# l=list({'a':1,'b':2})
# print(l)

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
# names=['alex','wxx','lxx','egon']         #将ALEX存入列表中
# names[0]='ALEX'

# print(names)
#2、切片(顾头不顾尾，步长)
# names=['alex','wxx','lxx','egon']
# print(names[0:3])

#3、长度
# names=['alex','wxx','lxx','egon']
# print(len(names))

#4、成员运算in和not in
# names=['alex','wxx','lxx','egon',4]
# print(4 in names)


#5、追加
# names=['alex','wxx','lxx','egon']
# names.append('cxx1')
# names.append('cxx2')
# names.append('cxx3')
# print(names)

#6、删除
# names=['alex','wxx','lxx','egon']
# del names[2]

# print(names)

#7、循环
# names=['alex','wxx','lxx','egon']
# for name in names:
#     print(name)

# 需要掌握的操作(****)
# names=['alex','wxx','lxx','egon',4,3.1]           #在列表指定位置插入元素
# names.insert(1,'SB')
# print(names)

# names=['alex','wxx','lxx','egon',4,3.1]
# res=names.remove('wxx')  # 单纯的删掉,是按照元素的值去删除，没有返回值
# print(res)
# print(names)


names=['alex','wxx','lxx','egon',4,3.1]
res=names.pop(1) #拿走一个值,是按照索引去删除,有返回值
print(names)
print(res)

# names=['alex','wxx','lxx','egon',4,3.1]
# print(names.pop())
# print(names.pop())

# names=['alex','wxx','lxx','lxx','egon',4,3.1]
# print(names.count('lxx'))

# print(names.index('lxx'))                     #取索引值(所取元素的位置)

# names=['alex','wxx','lxx','lxx','egon',4,3.1]
# names.clear()                                 #清空列表
# print(names)

# names=['alex','wxx','lxx','lxx','egon',4,3.1]
# x=names.copy()                                #把names内列表复制到x
# print(x)

# names.extend([1,2,3])                         #把别的列表加到此列表后
# print(names)

# names.reverse()                               #把列表内的东西顺序倒过来
# print(names)

# names=[1,10,-3,11]
# names.sort(reverse=True)
# print(names)


#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意数据类型
#
# 2 有序or无序
# 有序
# 3 可变or不可变
# 可变

# l=['a','b']
# print(id(l))
# l[0]='A'
# print(id(l))

4.字典类型

#一：基本使用
# 1 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
#        当存储多个值表示的不同的状态时，
#
# 2 定义方式:{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
#value可以是任意数据类型，但是key必须为不可变类型，key通常应该是字符串类型，
# d={'x':1,'y':2} #d=dict({'x':1,'y':2})
# d=dict(a=1,b=2,c=3)
# print(d)


# dic={1:'a',0:'b',1.1:'c',(1,2,3):'d'}
# print(dic[1])
# print(dic[0])
# print(dic[1.1])
# print(dic[(1,2,3)])
# dic={[1,2,3]:'a'}
# dic={{'x':1}:'a'}

#
# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
# d={'x':1,'y':2}
# d['x']=100
# print(d)
# d['z']=3
# print(d)

# l=['a','b']
# l[2]='c'                 #会报错

#2、长度len
# d={'x':1,'y':2}         #key的长度
# print(len(d))

#3、成员运算in和not in
# d={'x':1,'y':2}
# print('x' in d)

#4、删除
d={'x':1,'y':2}
# del d['x']                    #删除所选的key及对应的value,返回值为value
# print(d)
# res=d.pop('y')
# print(d)
# print(res)

# res=d.popitem()
# print(d)                      #随机删除,返回值为元组
# print(res)

# d={'a':1,'b':2,'c':3,'d':4}
# for k in d:
#     print(k)

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

#5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
names=[]
for k in msg_dic:
    names.append(k)
print(names)
# values=[]
# for k in msg_dic:
#     values.append(msg_dic[k])
# print(values)

# keys=msg_dic.keys()
# print(keys)
# for k in keys:
#     print(k)=
# l=list(keys)
# print(l)

# vals=msg_dic.values()
# print(vals)
# print(list(vals))

# print(msg_dic.items())
# print(list(msg_dic.items()))
#6、循环
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
# 只取key
# for k in msg_dic:
#     print(k,msg_dic[k])

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

# 只取value
# for v in msg_dic.values():
#     print(v)

#取key和value
# for k,v in msg_dic.items(): #k,v=('apple', 10)
#     print(k,v)

# 需要掌握的内置方法（****）
# d={'x':1,'y':2,'z':3}
# v=d.get('xxxx')
# print(v)
# print(d['xxxxxxx'])

# d={'x':1,'y':2,'z':3}
# d1={'a':1,'x':1111111}
# d.update(d1)
# print(d)

# l=['name','age','sex']
# d={}
# for k in l:
#     d[k]=None
# d=dict.fromkeys(l,None)
# print(d)


# info.setdefault
info={'name':'egon','age':18,'sex':'male'}

# 如果字典中有setdefault指定的key，那么不改该key对应的值，返回原的value
res=info.setdefault('name','EGON_NB')
print(info)
print(res)

# 如果字典中没有setdefault指定的key，那么增加一个key:value,返回新的value
# info.setdefault('height',1.80)
# print(info)

# info={'age':18,'sex':'male'}
# v=info.setdefault('name','浩哥')
# print(v)




s='hello alex alex say hello sb sb'
l=s.split()
# print(l)
d={}
# for word in l: #word=  'hello'
#     if word not in d:
#         d[word]=1 #{'hello':2, 'alex':2,'say':1}
#     else:
#         d[word]+=1
# print(d)

s='hello alex alex say hello sb sb'
l=s.split()
print(l)
d={}

# d={'hello':2,'alex':2}
for word in l: #word='alex'
    # d[word]=l.count(word) #d['alex']=2
    d.setdefault(word,l.count(word))

print(d)











# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型，而key必须是不可变类型，通常应该是不可变类型中字符串类型
#
# 2 有序or无序
# 无序
#
# 3 可变or不可变

d={'x':1,'y':2}
# print(id(d))
# d['x']=1111
# print(id(d))

d=123

5.元组类型

# 一：基本使用
# 1 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组合最合理
#
# 2 定义方式:在()内用逗号分割开，可以存放任意类型的值
# names=('alex','egon','wxx') #names=tuple(('alex','egon','wxx'))
# print(type(names))
# 强调: 当元组内只有一个元素时，务必记住加一个逗号
# x=('egon',)
# print(type(x))

# 3 常用操作+内置的方法
# 1、按索引取值(正向取+反向取)：只能取
# names=('alex','egon','wxx')
# names[0]='sb'


# 2、切片(顾头不顾尾，步长)
# names=('alex','egon','wxx','lxx','cxxx')
# print(names[1:3]
# )

# 3、长度
# names=('alex','egon','wxx','lxx','cxxx')
# print(len(names))
# 4、成员运算in和not in
# names=('alex','egon','wxx','lxx','cxxx')
# print('alex' in names)

# 5、循环
# names=('alex','egon','wxx','lxx','cxxx')
# for item in names:
#     print(item)


# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意数据类型
#
# 2 有序or无序
# 有序
# 3 可变or不可变
# 不可变

# names=('alex','egon','wxx','lxx','cxxx','lxx')
# del names[0]
# names[0]='sb'
# print(names.count('lxx'))
# print(names.index('wxx',0,3))

# names=('alex','egon','wxx','lxx','cxxx','lxx')
# names=1

# l=[1,243,3]
# l=3333
# l=['a','b','c']
# print(id(l[0]))
# l[0]='A'
# print(id(l[0]))

# names=('a','b','c')

# 列表可变的底层原理：
# 指的是索引所对应的值的内存地址是可以改变的

# 元组不可变的底层原理：
# 指的是索引所对应的值的内存地址是不可以改变的
# 或者反过来说，只要索引对应值的内存地址没有改变，那么元组始终是没有改变的

t1 = (['a', 'b', 'c'], 'wc', 'office')

print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))

t1[0][0] = 'AAAA'
print(t1)

print(id(t1[0]))

6.集合类型

# pythoners=['王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱']
# linuxers=['陈独秀','wxx','egon','张全蛋']
#
# l1=[]
# for stu in pythoners:
#     if stu in linuxers:
#         # print(stu)
#         l1.append(stu)
#
# print(l1)
#
# l2=[]
# for stu in pythoners:
#     if stu not in linuxers:
#         # print(stu)
#         l2.append(stu)
#
# print(l2)



#一：基本使用
# 1 用途: 关系运算、去重
#
# 2 定义方式:{}内用逗号分隔开多个元素，每一个元素都必须是不可变（即可hash）类型
#强调：
#2.1 集合内元素都必须是不可变（即可hash）类型
#2.2 集合内的元素无序
#2.3 集合内的元素不能重复

# s={1,2,'a'} #s=set({1,2,'a'})
# print(type(s))

# s={1.1,1,'aa',(1,2,3),{'a':1}}

# s={1,'a','hello',(1,2,3),4}
# for item in s:
#     print(item)

# s={1,1,1,1,1,1,1,1,1,'a','b','a'}
# s={(1,2,3),(1,2,3),'a','b','a'}
# print(s)

# s=set('hello')
# print(s)

# 单纯的用集合去重，需要注意的问题是
#1、去重的目标所包含的值必须都为不可变类型
#2、去重的结果会打乱原来的顺序
# names=['asb','asb','asb','wsb','wsb','egon_nb',[1,2,3]]
# s=set(names)

# names=list(s)
# print(names)

#
# 3 常用操作+内置的方法
#优先掌握的操作：
#1、长度len
# pythoners={'王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱'}
# print(len(pythoners))

#2、成员运算in和not in
# print('李二丫' in pythoners)


pythoners={'王大炮','李二丫','陈独秀','艾里克斯','wxx','欧德博爱'}
linuxers={'陈独秀','wxx','egon','张全蛋'}
#3、|并集
# print(pythoners | linuxers)                         #合并并去重
# print(pythoners.union(linuxers))

#4、&交集
# print(pythoners & linuxers)
# print(pythoners.intersection(linuxers))           #取两个集合相交的部分
# print(linuxers & pythoners)
#5、-差集
# print(pythoners - linuxers)
# print(pythoners.difference(linuxers))             #第一个集合减去交集
# print(linuxers - pythoners)
# print(linuxers.difference(pythoners))
#6、^对称差集
# print(pythoners ^ linuxers)                         #两者的并集减去交集
# print(pythoners.symmetric_difference(linuxers))

# print(linuxers ^ pythoners)
#7、==
# s1={1,2,3}
# s2={1,2,3}
# print(s1 == s2)

#8、父集(包含关系)：>,>=
# s1={1,2,3,4,5}
# s2={1,2,3}
# print(s1 > s2) # s1包含s2
# print(s1.issuperset(s2))
# print(s2.issubset(s1))

# s3={1,2,10}
# print(s1 > s3)

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

#9、子集(被包含的关系)：<,<=

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

# s1.update({4,7,8,9})
# print(s1)

# res=s1.pop()
# print(res)

# res=s1.remove(4)
# print(res)
# print(s1)

s1={1,2,3,4,5}
s2={2,3,7,8}
# s1=s1 - s2
# print(s1)
# s1.difference_update(s2) # s1=s1 - s2
# print(s1)

# s1={1,2,3,4,5}
# s1.pop()
# s1.remove(7)
# s1.discard(7) # 即便要删除的元素不存在也不会报错

# s1={1,2,3,4,5}
# s2={5,6,7,8}
# print(s1.isdisjoint(s2))



#
# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都必须为不可变类型
#
# 2 有序or无序
# 无序
#
# 3 可变or不可变
# set集合是可变类型
# s={1,2,3}
# print(id(s))
# s.add(4)
# print(s)
# print(id(s))



#=====================集合的去重==========================
# 单纯的用集合去重，需要注意的问题是
#1、去重的目标所包含的值必须都为不可变类型
#2、去重的结果会打乱原来的顺序
# names=['asb','asb','asb','wsb','wsb','egon_nb',[1,2,3]]
# s=set(names)

# names=list(s)
# print(names)

stu_info=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'oldboy','age':84,'sex':'female'},
]

new_info=[]
for info in stu_info:
    if info not in new_info:
        new_info.append(info)

print(new_info)