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

#二：该类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型

2 有序or无序

3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

#整型int
    作用：年纪，等级，身份证号，qq号等整型数字相关
    定义：
        age=10  #本质age=int(10)

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

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

#二进制，十进制，八进制，十刘进制

#作用： 名字，性别，国籍，地址等描述信息
#定义： 在单引号、双引号、三引号内，由一串字符组成
name='egon'

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


移除空白strip
切分split
循环

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))            #判断字给定字符串是否在结尾，如果在则返回True,不在则为False
print(name.startswith('alex'))           #判断给定字符串是否在开头，如果在则返回True,不在则为False

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))                #替换，把alex替换为SB，1表示只替换匹配到的第一个字符串

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')        #format,自定义格式，注意中间的空格。把format后面的字符串放入大括号中。
res='{1} {0} {1}'.format('egon',18,'male')    #按照输入的位置，按0，1，2，3指定位置排列。
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)        #设置变量，指定变量的位置，format后面的输入顺序就不重要了。

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('0',1,3))  #查找0，顾头不顾尾，找不到则返回-1不会报错，找到了则显示索引
# print(name.index('e',2,4)) #同上，但是找不到会报错
print(name.count('e',1,3))  #顾头不顾尾，如果不指定范围则查找所有

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #指定冒号为默认分隔符 为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1))   #从右开始切分



#join
tag=' '
print(tag.join(['egon','say','hello','world']))  #可迭代对必须都是字符串,把tag加入到对应的字符串中。

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))        #30为总字符串，让name在30个字符中居中，不够的用-填充。
print(name.ljust(30,'*'))            #30为总字符串，让name在30个字符中排最左，不够用*填充
print(name.rjust(30,'*'))            #30为总字符串，让name在30个字符中排最右，不够用*填充。
print(name.zfill(50))   #用0填充50个字符,name在最右。

#expandtabs
name='egon\thello'        #\t制表符
print(name)                   
print(name.expandtabs(1))        #1为指定多少个字隔做为分隔符号。

#lower,upper
name='egon'
print(name.lower())            #全替换为小写
print(name.upper())            #全替换为大写

#captalize,swapcase,title
print(name.capitalize())    #首字母大写
print(name.swapcase())      #大小写翻转
msg='egon say hi'
print(msg.title())      #每个单词的首字母大写


#is数字系列
#在python中
num1=b'4'   #bytes
num2=u'4'   #unicode,python3中无需加u就是unicode
num3='四'    #中文数字
num4='IV'   #罗马数字


#isdigt:bytes,unicode
print(num1.isdigit())   #True
print(num2.isdigit())   #True
print(num3.isdigit())   #False
print(num4.isdigit())   #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.isdigit())
print(num5.isdigit())
'''
总结：
    最常用的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())

# 写代码，有如下变量，请按照要求实现每个功能
name = " aleX"
# 1)    移除name 变量对应的值两边的空格，并输出处理结果
# 2）    判断name变量对应的值是否以"al"开头，并输出结果
# 3）    判断name变量对应的值是否以"X"结尾，并输出结果
# 4）    将 name变量对应的值中的"1"替换为"p"，并输出结果
# 5）    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

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

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

# 写代码，有如下变量，请按照要求实现每个功能
name = 'alex'

#1) 移除name变量对应的值两边的空格，并输出处理结果
name = 'alex'
a=name.strip()
print(a)

# 2) 判断name 变量对应的值是否以"al"开头，并输出结果
name='alex'
if name.startswith(name):
    print(name)
else:
    print('no')

# 3）    将name变量对应的值是否以"x"结尾，并输出结果
name='alex'
if name.endswith(name):
    print(name)
else
    print('no')

# 4) 将name变量对应的值中的"1"替换为"p",并输出结果
name='alex'
print(name.replace('1','p'))


# 5) 将name 变量对应的值根据"1"分割，并输出结果。
name='alex'
print(name.split('1'))

# 6)  将name变量对应的值变大写，并输出结果
name='alex'
print(name.upper())

# 7)  将name变量对应的值变小写，并输出结果
name='alex'
print(name.lower())

# 8) 请输出name变量对应的值的第2个字符？
name='alex'
print(name[1])

# 9) 请输出name变量对应的值的前3个字符
name='alex'
print(name[:3])

# 10） 输出name变量对应的值的后2个字符
name='alex'
print(name[-2:1])

# 11)  请输出name变量对应的值中"e"所在索引位置
name='alex'
print(name.index('e'))

# 12)  获取子序列，去掉最后一字符。如：oldboy 则获取oldbo
name='alex'
a=name[:-1]
print(a)

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

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

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

追加
删除
循环

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

1. 有列表data=['alex',49,[1900,3,18]],分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
2.用列表模拟队列
3.用列表模拟堆栈
4.有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]
答案：
l.sort(key=lambda item:item['age'])
print(1)

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

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

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


循环

#简单购物车，要求如下：
实现打印商品详细信息，用户输入商品名和购买数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入

msg_dic={
    'apple':10,
    'tesla':100000,
    'mac':3000,
    'lenovo':30000,
    'chicken':10,
}

msg_dic={
    'apple':10,
    'tesla':100000,
    'mac':3000,
    'lenovo':30000,
    'chicken':10,
}
goods_l=[]
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)

#作用： 存多个值，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.有如下值集合[11,22,33,44,55,66,77,88,99,90...],将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中

即：  {'k1': 大于66的所有值，'k2': 小于66的所有值}

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    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)




#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

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

#定义：
        知识点回顾
        可变类型是不可hash类型
        不可变类型是可hash类型

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

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

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


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

    二.去重

    1.有列表l=['a','b',l,'a','a'],列表元素均可hash类型，去重，得到新列表，且新列表无需保持列表原来的顺序

    2.在上题的基础上，保存列表原来的顺序

    3.去除文件中重复的行，肯定要保持文件内容的顺序不变
    4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表一定要保持列表原来的顺序

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=['a','b',l,'a','a']
print(set(1))

#去重，并保持原来的顺序
#方法一：不用集合
l=[l,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)

print(l1)
#方法二：借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)
print(l1)

#同上方法二，去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时，去重，并且保持原来顺序
l=[
    {'name':'egon','ag':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'female'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]

# print(set(1))  #报错：unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)

print(l1)

#定义函数，既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(1,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

按存储空间的占用分（从低到高）
数字
字符串
集全：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

#身份运算（is, is not)
is 比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同

>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040,31550448)
>>> x is y
False