Day2-数据类型、字符编码、购物车

一、引子

1、什么是数据？

x=10，10是我们要存储的数据。

2、为何数据要分不同的类型？

数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示。

3、存在哪些数据类型

• 数字（整形，长整形，浮点型，复数）
• 字符串
• 列表
• 元组
• 字典
• 集合

4、按照以下几个点展开数据类型的学习

#一：基本使用
1 用途
2 定义方式
3 常用操作+内置的方法

#二：该类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型
2 有序or无序 　　　
    能按位置取值，就是有序；否则无序
3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

 二、数字

1、整型与浮点型

#一：int（无内置方法）
#作用：年龄，级别，等级，身份证号
x=10 #x=int(10)
print(id(x),type(x),x)

#二：float
#作用：工资，身高，体重
salary=3.1 #salary=float(3.1)
print(id(salary),type(salary),salary)

数字无长度！

2、其他数字类型（了解）

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0

3、实操

int与float为不可变类型：
>>> x=123
>>> id(x)
4297640800
>>> x=12345
>>> id(x)
4320497584

>>> x=3.14
>>> id(x)
4300280000
>>> x=9.11
>>> id(x)
4300280120

>>> x=123
>>> y=123
>>> id(x)
4297640800
>>> id(y)
4297640800

>>> x=1234567890
>>> y=1234567890
>>> id(x)
4320497488
>>> id(y)
4320497584

is身份判断，判断id是否相等 identify
>>> x==y
True
>>> x is y
False

也就是说，值相等，id可以不一样：申请两个内存空间，放同样的值；
如果id一样，那么它们用的是同一个内存空间，所以类型、值全部一样。
>>> x=123
>>> y=x
>>> x is y
True
>>> x==y
True
>>> 

但，当数据量比较小的时候：小到没必要把时间耗费在申请内存空间上。
>>> x=123
>>> y=123
>>> id(x)
4297640800
>>> id(y)
4297640800

字符串同理：
>>> x='abcdefg'
>>> y='abcdefg'
>>> id(x)
4320792392
>>> id(y)
4320792392
>>> x='Today is Monday'
>>> y='Today is Monday'
>>> id(x)
4320819568
>>> id(y)
4320819632

三、字符串；

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

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

#优先掌握的操作：
按索引取值(正向取+反向取) ：只能取
切片(顾头不顾尾，步长)
长度len
成员运算in和not in

移除空白strip
切分split

1、实操

#用途：名字，性别，地址
name='guoxq' #name=str('guoxq')
# print(id(name),type(name),name)

#优先掌握的操作：
# 按索引取值(正向取+反向取) ：只能取
# print(name[0],type(name[0]))
# print(name[-2])
# name[0]='E'                    #字符串不支持插入字符

# 切片(顾头不顾尾，步长)
# print(name[1:3])
# msg='hello world'
# print(msg[1:7])
# print(msg[1:7:2])

# msg='abcdefg' 　　　　#bdf
# # print(msg[1:6:2])
# # print(msg[::2])
# print(msg[6::-1]) #了解

# print(msg[5:0:-1])  #顾头不顾尾，所以取不到a
# print(msg[5::-1])   #去掉零，就可以取全

# 长度len
# msg='ab c '
# print(len(msg))

# 成员运算in和not in
# msg='hello alex'
# print('a' in msg)
# print('alex' in msg)
# print('ae' not in msg)

# 移除空白strip
# password='   alex3714              '
# password=password.strip()
# print(password)
# print(password.strip())

# msg='***egon***********'
# print(msg.strip('*'))
# msg='***eg**on***********'
# print(msg.strip('*'))

# 切分split
user_info='root:x:0:0::/root:/bin/bash'
# print(user_info[0:4])
# print(user_info.split(':')[0])　　　　#取第0个值
# print(user_info.split(':',1))　　　　#切一次

# cmd='put       a.txt'
# print(cmd.split())

# filepath='put /a/b/c/d/a.txt'
# print(filepath.split())

# filepath='/a/b/c/d/a.txt'
# print(filepath.split('/')[-1])

# msg='alex say i have on tesla'
# print(msg.split(maxsplit=1)[0])           #切一次，取第0个值

#isdigit:用来判断字符是否是由纯数字组成（bytes，unicode）

#常用操作
# 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 telsa, my name is alex'
# print(msg.replace('alex','SB',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))　　　　#‘egon’对应0；18对应1

# print('my name is {x} my age is {y}'.format(y=18,x='egon'))　　　　#可以无序

#split
# user_info='root:x:0:0::asdfasdf'
# l=user_info.split(':')

#join
# print(':'.join(l))　　　　#将上面l返回的列表，用:再连接起来，与原来一样；
# print(''.join(l))
# print(' '.join(l))

#center,ljust,rjust,zerofill
#=================egon===================
# print('egon'.center(30,'='))
# print('egon'.rjust(30,'='))
# print('egon'.ljust(30,'='))
# print('egon'.zfill(30))

#了解部分
#find,rfind,index,rindex,count
# msg='hello world'
# print(msg.find('ell'))　　　　#从左到右找，如果有，则返回第一个字符的索引
# print(msg.find('easdfasdf'))　　　　#从左到右找，如果没有，返回-1

# print(msg.index('d',0,3))　　　　#从左到右找，如果有，则返回第一个字符的索引
# print(msg.index('x'))　　　　#从左到右找，如果有，则返回第一个字符的索引

# print(msg.count('l',0,4))
# print(msg.count('l',0,3))

# msg='abc\tdeft'
# print(msg.expandtabs(3))　　　　#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())
# print(msg.islower())
# print(msg.istitle())

# msg='asasdf123'
# print(msg.isalnum()) 　　#字符串是由字母或数字组成
msg='asdfasdf'
print(msg.isalpha())　　　　#字符串是由字母组成的

# msg='   1'
# print(msg.isspace())　　　　#字符串都是空格吗？都是空格为真
# msg='aaaai fabc'
# print(msg.isidentifier())　　　　#字符串不存在空格吗？不存在为真

#判断数字
# age=10
# inp=input('>>: ').strip()
# if inp.isdigit():　　　　#isdigit能判断bytes和unicode
#     inp=int(inp)
#     if inp > age:
#         print('ok')
#
# else:
#     print('必须输入数字')

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

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

#unicode
# print(num2.isdecimal())　　　　#isdecimal也能判断数字，但是没有isdigit判断的全面
# print(num3.isdecimal())
# print(num4.isdecimal())
# print(num5.isdecimal())

#unicode,汉字，罗马
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
# print(num5.isnumeric())

2、练习题：

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
# name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# print(name.strip())
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

# print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# print(name.endswith('X'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# print(name.replace('l','p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果

# print(name.upper())
# 7)    将 name 变量对应的值变小写,并输出结果

# print(name.lower())
# 8)    请输出 name 变量对应的值的第 2 个字符?
# print(name[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
# print(name[0:3])
# 10)    请输出 name 变量对应的值的后 2 个字符?

# print(name[3:])
# or
# name=' aleX'
# print(name[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# print(name.index('e'))
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
# name=' oldboy '
# print(name[0:6])

name=' oldboy '
print(name[:-2])

四、列表

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

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

#优先掌握的操作：
按索引存取值(正向存取+反向存取)：即可存也可以取      
切片(顾头不顾尾，步长)
长度
成员运算in和not in
追加
删除

1、注意步长

#ps:反向步长
l=[1,2,3,4,5,6]

#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]

 

2、实操

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])

#优先掌握的操作：
# 按索引存取值(正向存取+反向存取)：即可存也可以取
# print(my_girl_friends[2])
# print(my_girl_friends[-1])
# print(id(my_girl_friends))
# my_girl_friends[0]='SB'
# print(id(my_girl_friends))
# print(my_girl_friends)

# 切片(顾头不顾尾，步长)
# print(my_girl_friends[0:2])
# print(my_girl_friends[0:4:2])

# 长度
# print(len(my_girl_friends))　　　　#元素个数

# 成员运算in和not in
# print('alex' in my_girl_friends)
# print(5 in my_girl_friends)

# 追加
# my_girl_friends.append('6号')　　　　#默认加在后面
# print(my_girl_friends)

# 删除
# del my_girl_friends[2]
# print(my_girl_friends)

# print(my_girl_friends.remove('yuanhao')) #remove是单纯的删除，不会返回删除的值，并且是按照值去删
# res=my_girl_friends.pop(1) #按照索引取删，默认从末尾开始删
# print(res)　　#返回删除的值

# my_girl_friends.pop() #按照索引取删，默认从末尾开始删
# print(my_girl_friends)

#常用操作：
my_girl_friends=['alex','wupeiqi','alex','yuanhao',4,5] #本质my_girl_friends=list([...])
# my_girl_friends.insert(0,'sb_alex')
# my_girl_friends.insert(2,'yh')

# my_girl_friends.extend([1,2,3,4])　　　　#默认向末尾扩展

# print(my_girl_friends.count('alex'))

#了解
# 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)

3、练习题：

#队列：先进先出
#append，pop
# l1=[]
# l1.append('first')
# l1.append('second')
# l1.append('third')

# print(l1.pop(0))
# print(l1.pop(0))
# print(l1.pop(0))

#堆栈：先进后出
# l1=[]
# l1.append('first')
# l1.append('second')
# l1.append('third')

# print(l1.pop())
# print(l1.pop())
# print(l1.pop())

同上：
l1=[]
l1.insert(0,'first')
l1.insert(0,'second')
l1.insert(0,'third')
print(l1)
print(l1.pop(0))
print(l1.pop(0))
print(l1.pop(0))

END. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1900,3,18]]
name=data[0]
age=data[1]
year=data[2][0]
month=data[2][1]
day=data[2][2]
print(name,age,year,month,day)

 五、元组

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

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

#优先掌握的操作：
按索引取值(正向取+反向取)：只能取   
切片(顾头不顾尾，步长)
长度
成员运算in和not in

1、实操

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
#定义方式：
ages=(10,12,18,33,18) #ages=tuple((10,12,18,33))
# print(id(ages),type(ages),ages)


#优先掌握的操作：
# 按索引取值(正向取+反向取)：只能取
# 切片(顾头不顾尾，步长)
# print(ages[0:2])
# print(ages)
# 长度
# print(len(ages))
# 成员运算in和not in
# print(10 in ages)

#其他操作：
# print(ages.index(18))
# print(ages.index(123123123123))　　　　#报错，他不在tuple（元组）里面
# print(ages.count(18))　　　　#18出现几次

# l=['a','b','c','d','e']
# # l='abcde'
# l=('a','b','c','d','e')
# index=0
# while index < len(l):
#     print(l[index])
#     index+=1

# l1=['a','b','c','d','e']
# for item in l1:
#     print(item)

# l2='abcde'
# for item in l2:
#     print(item)

# for i in range(1,10,2):
#     print(i)

# l1=['a','b','c','d','e']
# for i in range(len(l1)):
#     print(i)
#     print(i,l1[i])

2、练习题：

#简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods_l=[]
# while True:
#     for item in msg_dic:
#         print(item,msg_dic[item])
#     choice=input('请输入您想要购买的商品： ').strip()
#     if choice not in msg_dic:continue
#     count=input('请输入您要购买的个数： ').strip()
#     if count.isdigit():
#         goods_l.append((choice,msg_dic[choice],int(count)))
#         print(goods_l)

while True:
    for item in msg_dic:
        print(item,msg_dic[item])
    choice=input('请输入您想要购买的商品： ').strip()
    if choice in msg_dic:
        count=input('请输入您要购买的个数： ').strip()
        if count.isdigit():
            goods_l.append((choice,msg_dic[choice],int(count)))
            print(goods_l)
    else:
        print('请输入列表里的产品： ')

下一节字典知识的运用：
while True:
    for key,item in msg_dic.items():
        print('name:{name} price:{price}'.format(price=item,name=key))
    choice=input('商品>>: ').strip()
    if not choice or choice not in msg_dic:continue
    count=input('购买个数>>: ').strip()
    if not count.isdigit():continue
    goods_l.append((choice,msg_dic[choice],count))
    print(goods_l)

3、补充了解知识点（for）

#while+else

# for i in range(5):
#     if i == 3:break
#     print(i)
# else:
#     print('ok')

for也支持+else和break。

六、字典

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

#优先掌握的操作：
按key存取值：可存可取
长度len
成员运算in和not in

删除
键keys()，值values()，键值对items()

1、实操：

#定义：key必须是不可变类型，value可以是任意类型
# d={'a':1}
# d={0:1}
# d={[1,2,3]:1} 　　#列表不能当做字典的key
# d={(0,'mac'):3000}
# print(d[(0,'mac')])

info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
#优先掌握的操作：
# 按key存取值：可存可取
# print(info['sex'])
# info['hobbies']=['read','music','play','sleep','eat']
# print(info)

# 长度len
# print(len(info))

# 成员运算in和not in

# 删除
# print(info.pop('name'))
# print(info.pop('name1213','确实是没有的，我的哥'))
# print(info.pop('name1213',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['name123'])
# print(info.get('name123',123))　　　　#取值不报错
# print(info.popitem())　　　　#弹出最后一个key-value，pop是弹出value

# for k,v in info.items(): 　　#k,v=('name', 'egon')
#     print(k,v)

# print(info.setdefault('hobbies',['read','music'])) #有则不改，返回已经有的值，没有则新增，返回新增的值
# print(info)

# print(id(info.setdefault('hobbies',[])))　　　　#id一样
# print(id(info['hobbies']))

info={'name':'egon','age':18,'sex':'male',}
# if 'hobbies' not in info:
#     info['hobbies']=[]
#     info['hobbies'].append('music')
# else:
#     info['hobbies'].append('read')
#
# if 'hobbies' not in info:
#     info['hobbies'] = []
#     info['hobbies'].append('music')
# else:
#     info['hobbies'].append('read')
#
# print(info)

# info.setdefault('hobbies',[]).append('music')

# # {'name': 'egon', 'age': 18, 'sex': 'male', 'hobbies': ['music', ]}
# info.setdefault('hobbies',[]).append('read') 　　　　#['music', ].append('read')
# print(info)

#了解
# info_new={'a':1,'age':19}　　　　#'a'新增，‘age'更新
# info.update(info_new)
# print(info)

# dic={'name':None,'age':None,'sex':None,'hobbies':None}
# dic1={}.fromkeys(['name','age','hobbies'],None)
# print(dic1)

#补充两种赋值方式：
#一：链式赋值
# x=10
# y=x
# x=y=z=10
# print(id(x),id(y),id(z))

#交换两个变量的值
# m=10
# n=20
# temp=n
# n=m #n=10
# m=temp
# print(m,n)

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

# x,_,_,_,b=t
# print(x,b)
# print(_)

# x,*_,b=t　　　　#*后面多个_
# print(x,b)

# x,*_='hello'
# print(x)

# x,y,z={'a':1,'b':2,'c':3}　　　　#取值
# print(x,y,z)

2、练习题：

#1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
#即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

# l=[11,22,33,44,55,66,77,88,99,90]
# a={'k1':[],'k2':[]}
# for i in l:
#     if i > 66:
#         a['k1'].append(i)
#     else:
#         a['k2'].append(i)
# print(a)

# 2 统计s='hello alex alex say hello sb sb'中每个单词的个数
# 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
# s='hello alex alex say hello sb sb'
# l=s.split()
# dic={}
# for item in l:
#     if item in dic:
#         dic[item]+=1
#     else:
#         dic[item]=1
# print(dic)

# s='hello alex alex say hello sb sb'
# dic={}
# words=s.split()
# print(words)
# for word in words: #word='alex'
#     dic[word]=s.count(word)
# print(dic)

#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) 　　#返回1

d={'a':2222}
print(d.setdefault('a',1)) 　　#返回2222
'''
# s='hello alex alex say hello sb sb'
# dic={}
# words=s.split()
# for word in words: 　　#word='alex'
#     dic.setdefault(word,s.count(word))
#     print(dic)

七、集合

#作用：去重，关系运算，

#定义：
            可变类型是不可hash类型
            不可变类型是可hash类型

#定义集合:
            集合：可以包含多个元素，用逗号分割，
            集合的元素遵循三个原则：
            1：每个元素必须是不可变类型(可hash，可作为字典的key)
            2：没有重复的元素
            3：无序

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

#优先掌握的操作：
长度len
成员运算in和not in

|合集
&交集
-差集
^对称差集
==
>，>= ，<,<= 父集，子集 

 1、实操：

# pythons=['alex','wupeiqi','egon','yuanhao','gangdan','oldboy']
# linuxs=['egon','oldboy','tiedan','liudan']

# l=[]
# for item in pythons:
#     if item in linuxs:
#         l.append(item)　　　　#找出即报名python又报名linux的学员
# print(l)

# s={1,2,'a','b','c','d','e','f'} 　　#s=set({1,2,'a'})
# print(type(s),s)

# 优先掌握的操作：
# 长度len
# s={1,2,'a','b','c','d','e','f'}
# 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)

# -差集　　　　#在s1里，不在s2里，或在s2里，不在s1里
# print(s1 - s2)
# print(s2 - s1)

# ^ 对称差集　　　　#共有部分之外的部分
# s1={1,2,3}
# s2={3,4,5}

# ==
# > ， >= ， <, <= 父集，子集
# s1={1,2,3,4}
# s2={3,4,5}
# print(len(s1) > len(s2))

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

#常用操作
s1={1,2,3,'a',4}
# print(s1.pop()) 　　#随机删，并返回删除的结果

# s1.remove('a') 　　#单纯地删，不会返回删除的结果，并且如果删除的元素不存在则报错
# s1.remove('asdfasdfa') 　　#单纯地删，不会返回删除的结果
# print(s1)
# print(s1.discard('a'))　　 #单纯地删，不会返回删除的结果，并且如果删除的元素不存在返回None，不会报错
# print(s1)

# s1.add('b')
# print(s1)

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

#了解
# s1={1,2,3,4}
# s2={3,4,5}

# | 并集
# print(s1.union(s2))

# & 交集
# print(s1.intersection(s2))
# s1.intersection_update(s2) 　　#s1=s1.intersection(s2)
# print(s1)

# -差集
# print(s1.difference(s2))

# ^ 对称差集
# print(s1.symmetric_difference(s2))

# ==
# > ， >= ， <, <= 父集，子集
# s1={1,2,3,4}
# s2={3,4}
# print(s1.issuperset(s2))
# print(s2.issubset(s1))

#去重,无需保持原来的顺序
# l=['a','b',1,'a','a']
# print(set(l))
# print(list(set(l)))

#去重，需要保持原来的顺序
# l=['a','b',1,'a','a']
# l_new=[]　　　　　　#等同于 l_new=list()
# s=set()
# for item in l:
#     if item not in s:
#         s.add(item)
#         l_new.append(item)
# print(l_new)

#列表中元素为可变类型时，去重，并保持原来的顺序
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'},
]
l_new=list()
s=set()
for item in l:
    res = (item['name'], item['age'], item['sex'])
    if res not in s:
        s.add(res)
        l_new.append(item)
print(l_new)


#了解：不可变集合　　　　可变才有.add  .pop  .remove等
fset=frozenset({1,2,3})
fset.

 八、数据类型总结

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

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

2、按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

3、按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

4、按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

5、练习题：

# 1. 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数
# apple 10 3
# tesla 100000 1
# mac 3000 2
# lenovo 30000 3
# chicken 10 3
#
a=[
    {'name':'apple','price':10,'count':3},
    {'name':'tesla','price':100000,'count':1},
    {'name':'mac','price':3000,'count':2},
    {'name':'lenovo','price':30000,'count':3},
    {'name':'chicken','price':10,'count':3}
]
list=[]
num=0
res=0
for i in a:
    pri=i['price']*i['count']
    list.append(pri)
    while num < len(list):
        res+=list[num]
        num+=1
print(res)

# 2. 修改文件内容，把文件中的alex都替换成SB
# a='alex is a good teacher, alex has a tesla'
# print(a.replace('alex','SB'))

 

 九、作业