Python基础1

1，基本运算符

1.1:逻辑运算

逻辑运算的优先级：（） >  not >  and  >  or ，从左往右运算

x or y : if x is false then y,else x      如果x是TRUE，则返回x

          例子：print（6 or 2 > 1） 输出是：6      print(5 < 4 or 3)返回：3    print（2 > 1 or 6）返回:Ture

x and y: if x is false then x ,else y    如果x是True,则返回y

        记住：只用记住or一个，and与or是相反的。

not x :if x is false then true ,else false

1.2：转换

int转换bool   :非零转换bool为True   例子：print(bool(2))返回True

bool转换 int: print(int(True))返回1

1.3:作业回顾，1-2+3-4+5-6+........+99,中间去掉88

# 计算1-2+3-4+5-6...-99,中除了88以为所有数的总和。+87-89+90...
# 方法1
i = 1
j = -1
sum1 = 0
while i < 100:
    if i == 88:
        i = i + 1
        continue
    else:
        j = -j
        sum1 = sum1 + i * j
        i = i + 1
print(sum1)
# 方法2
i = 0
j = -1
sum1 = 0
while i < 99:
    i = i + 1
    if i == 88:
        #i = i + 1
        continue
    else:
        j = -j
        sum1 = sum1 + i * j
        #i = i + 1
print(sum1)
# 计算1-2+3-4+5-6...+99,中除了88以为所有数的总和。+87+89-90+91...+99
sum = 0
i = 0
while i < 100:
    if i == 88:
        i = i + 1
        continue
    if i % 2 == 0:
        sum = sum - i
    else:
        sum = sum + i
    i = i + 1
print(sum)

1.4:作业回顾，用户三次登录

# 6,用户三次登录

i = 3
while i > 0:
    username = input("请输入账号：")
    password = input("请输入密码：")
    i = i - 1
    if username == "你好" and password == "你好":
        print("登录成功")
        break

    else:
        if i == 0:
            print("你已经没有机会了")
            answer = input("是否继续：Y")
            if answer == "Y":
                i = 3
        print("你还有"+str(i)+"次输入机会，请重新输入" )
# while下面的else,只要while不是被break打断的，else就会运行的
else:
    print("你要不要脸，还在试密码")

  2，基本数据类型

2.1：字符串

a = "ABCDEFGHJKL"  # 初始索引为0开始的
# 索引
print(a[1])
print(a[0])
print(a[-1])
#切片：通过索引（索引：索引：步长）来截取字符串的一段，行程新的字符串，顾首不顾尾原则
print(a[0:3])
print(a[0:])  #  取到最后
print(a[0:-1])  # -1是最有一个，但是顾头不顾尾，取不到最后一个“L”
print(a[0:7:2]) # 加步长 结果是ACEG
print(a[7:0:-2]) # 结果HFDB ，顾首不顾尾，这个“A”是取不到的

# # 字符串的操作
# s = "jsaoN cai"
# print(s.capitalize())  # 首字母大写 结果 Jason cai
# print(s.upper())  # 全部大写 结果 JASON CAI
# print(s.lower())  # 全部小写，结果 jason cai
# print(s.swapcase())  # 大小写翻转，结果JASOn CAI
# print(s.title())  # 首字母大写(特殊字符隔开的) 结果Jason Cai
# print(s.center(20))  # 把字符串居中，空白填充
# # 公共方法
# print(len(s))  # 字符串的长度  结果9
# print(s.startswith("js"))  # 判断以什么开头，返回值是bool值
# print(s.startswith("a", 2, 4))  # 索引的2-4位，是不是以a为开头
# # 通过元素找索引，找不到返回 -1
# print(s.find("j"))
# s = "  jason cai"
# print(s.strip())  # 默认去掉前后的空格
# s = "%jason cai*"
# print(s.strip("*%"))
# print(s.rstrip("*"))  # rstrip和lstrip只删左边或者右边
# s = "jason:cai"
# print(s.split(":"))  # 一分为2 字符串转为列表  str转list
# print(s.split("a"))
s = "aabbccdd223"
print(s.count("a")) # count计数，a字母的个数
print(s.replace("aa","ee")) #replace 替换
print(s.isalnum()) # is判断有字母或者数字组成
print(s.isalpha()) 

# 格式化输出，format的三种玩法
s = "我叫{}，今年{}岁，爱好{}，再重复一下我叫{}.".format("小明", 28, "girl", "小明")
print(s)
name = input("请输入你的名字：")
s = "我叫{0},今年{1}岁,爱好{2}，在重复一下我叫{0}." .format(name, 18, "gril")
print(s)
s = "我叫{name},今年{age}岁，爱好{hobbe},再重复一下我叫{name}" .format(name = name ,age = 18,hobbe = "gril")
print(s)
# 验证码不区分大小写,案例
"""
s_answer = "J52d"
you_input = input("请输入验证码，不区分大小写")
if you_input.upper() == s_answer.upper():
    print("验证成功")
else:
    print("验证码输入错误，请重新输入")
"""
jion方法

1、join()函数

语法：  'sep'.join(seq)

参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

2.2： for 循环

s = "kkkkkddde"
for i in s:
    print(i)
s = ",,,sddf苍井空，，，"
if '苍井空' in s:
    print('你的评论有敏感词')

2.3：数据类型之间的转换

# int数据类型
# int常用的就是这个方法，bit_length
i = 2
print(i.bit_length())  # 把数字转换为二进制的最小的位数
'''
1    0000 0001
2    0000 0010
3    0000 0011
'''
# str --->  int
s = '123'
i = int(s)
print(s)
# int --->  str
i = 321
s = str(i)
print(s)
# int ---> bool 非零的都是True
i = 11
b = bool(i)
print(b)
# str ---> bool 非空的都是True
s1 = ''
b1 = bool(s1)
s2 = ' '
b2 = bool(s2)
s3 = '0'
b3 = bool(s3)
print(b1)
print(b2)
print(b3)
# 工作中用到的 while True和whlie 1效果是一样的，1比True效率高，再计算机内部就是要把True转换为1的
'''
while True:
    pass
while 1:
    pass
'''
# 工作中用到的 input输入为空,如果s中什么都没有
'''
s
if s:
    print("你输入的为空，请重新输入")
else:
    pass
'''

2.4：编码

"""
编码
ascii: 字母，数字，特殊数字： 1个字节 8位（一个A字母：用8位表示，即A：00000010），没有中文
Unicode:16位：两个字节  升级后：32位表示4个字节（一个A字母，有32位表示，即A：00000000 00000010 00000001 00000100）
　　　　　　　　也有中文（中：00000000 00000010 00000001 00000100）utf-8:最少一个字节用8位表示，英文的一个字母用8位一个字节（A：00000010）            欧洲：16位两个字节

            中文：24位3个字节(中：00000010 00000001 00000100)
 gbk:中国人自己发明的，表示英文1个字节，中文2个字节 （一个字符A：00001100  一个中文中字：00101100 00110011）
注意：
1，各个编码之间的二进制，是不能互相识别的，会产生乱码
2，文件的储存和传输不能是Unicode（只能是utf-8,utf-18,gbk,gb3212,ascii）,因为Unicode占用空间太大
以上内容是python3和python2通用的
Python3: str类型在内存中使用Unicode编码
　　　　  bytes类型，也是一种数据类型，和str很像，用utf-8,gbk,ascii等编码的。
python3中，储存和传输的编码方式是：utf-8,gbk,ascii，但str的编码方式Unicode，所以str不能直接储存和传输，要转为bytes类型才能传输和储存
对于英文：
   str: 表现形式： s = 'jason'  
　　　　　编码方式：01010101 unicode
　　bytes:表现形式 s = b'jason'
　　　　　　编码方式：01001011 utf-8,gbk,ascii

# s = 'jason'
# s1 = b'jason'
# print(s,type(s))  # jason <class 'str'>
# print(s1,type(s1))  # b'jason' <class 'bytes'>

对于中文：
　　str: 表现形式： s = '中文'  

          编码方式：01010101 unicode

　　bytes:表现形式 s = b'x3erc32
32
43c23c34'  以三个字节表示一个汉字，是16进制表示中文，所以bytes对于中文是看不懂的。除了中文都可以的
　　　　　　编码方式：01001011 utf-8,gbk,ascii

# s = '中国'
# # s1 = b'中国' # 会报错
# print(s,type(s))  # jason <class 'str'>
以下是编码：

# encode编码，如何将str转换为bytes
# s1 = 'jason'
# s2 = s1.encode('utf-8')
# s3 = s1.encode('gbk')
# print(s2,type(s2))  # b'jason' <class 'bytes'>
# print(s3,type(s3))  # b'jason' <class 'bytes'>
# s1 = '中国'
# s2 = s1.encode('utf-8')
# s3 = s1.encode('gbk')
# print(s2,type(s2))  # b'xe4xb8xadxe5x9bxbd' <class 'bytes'>   三个字节
# print(s3,type(s3))  # b'xd6xd0xb9xfa' <class 'bytes'>   两个字节

"""

2.5：作业

# s = '132a4b5c'   # 作业输出123，然后用for和whlie循环分别打印字符串中的元素
# print(s[0]+s[2]+s[1])
# for i in s:
#     print(i)
# i = 0
# while i < len(s):
#      print(s[i])
#      i += 1
# 作业，计算两个数的加法，比如用户输入：5+9或者  5  +   9
# content = input("请输入加法：").strip()
# print(content)
# index = content.find("+")
# print(index)
# con1 = int(content[0:index])
# print(con1)
# con2 = int(content[index+1:])
# print(con2)
# print(con1 + con2)

#作业，计算用户输入的多位数的加法
# content = input("请输入加法：").strip()
# content_list = content.split("+")
# num = 0
# for i in content_list:
#     num += int(i)
# print(num)

# 作业，任意输入文字和数字，统计数字的个数
input_srt = input("请输入文字和数字")
num = 0
for i in input_srt:
    if i.isdigit():
         num += 1
print(num)

2.6：列表
2.6.1：增、删，改、查

# 列表
li = ['张三',12,'lisi',[1,2,3],'age']
# 增加 append 在最后增加
# li.append('wangwu')
# 增加作业，HR假如新员工的名字，持续的添加，如果有事按“Q”就暂时退出
# while 1:
#     new_name = input('请输入新增加员工的名字')
#     if new_name.strip() == "Q":
#         break
#     else:
#         if len(new_name)> 0:
#             li.append(new_name)
#         else:
#             pass
#插入方法，insert  按照索引去添加
# li.insert(2,'jason')
#可迭代的对象增加 extend
# li.extend('ab')  #结果：['张三', 12, 'lisi', [1, 2, 3], 'age', 'a', 'b']

# 删除 ：pop 按照索引删除，有返回值：删除的元素
# li.pop(2)  # 如果pop()是空的，默认删除最有一个元素
# del_object = li.pop(2)
# print(del_object,li)
# 删除，li.remove()按照元素删除
# li.remove("lisi")
# # 删除，清空列表 clear
# li.clear()
# 删除，del 直接删除列表
# del li
# 删除，切片删除 del li[]
# del li[2:]

# 修改 #按照索引值赋值
# li[0] = "男神"
# 修改，切片修改，效果是先把切片的删除，然后写多少都按照元素去添加
# li[0:2] = '男神'
# li[0:2] = ['nans','nvs']

# 查询
# for i in li:
#     print(i)
# print(li[0:1])  # 结果是一个列表

# 公共方法 长度，有几个元素
# print(len(li))
# # 公共方法，count显示出现的次数
# print(li.count("lisi"))
# 公共方法，index找出索引值
# print(li.index("lisi"))

# 排序，正向排序
li = [2,3,1,5,4]
# print(li.sort())
# 排序，反向排序
# print(li.sort(reverse=True))
# 排序，翻转
print(li.reverse())
print(li)

2.6.2：列表的嵌套

# 列表的嵌套
li = ['baozi','武藤兰','吴小二',['jason',18,'mason'],'jerry']
# 打印“藤”字
# print(li[1][1])  # 列表第一次切片是字符串，第二次是字符串的切片
# 把"bao zi"的首字母大写，并且替换
# li[0] = li[0].capitalize()
# 把“吴小二”的“二”改成“三”
# new = li[2].replace('二','三')
# li[2] = new
# 将“jason"全部改成大写，放回原来的位置
# li[3][0] = li[3][0].upper()

2.7：元祖，join,range

# 元祖，只读列表，可循环查询，切片，儿子不能改，孙子可能可以改
# tu = (1,2,3,'jason',[3,4,'mason'],'jerry')
# 把“mason"改成全大写
# tu[4][2] = (tu[4][2].upper())
# 在元祖中的列表添加元素
# tu[4].append('sb')
# print(tu)

# 字符串 join 方法，用连接符连接 join返回是一个字符串
# s = 'jason'
# s1 = '_'.join(s)
# print(s1)
# 用 join可以把列表转换为字符串  list --->  string
# tu = ['jason','jerry']
# s = '_'.join(tu)
# print(s)

# range 相当于用数字排序的列表，顾头不顾尾
# 打印1.2.3..9
# for i in range(1,10):
#     print(i)
# range还有步长,可以取奇数
# for i in range(1,10,2):
#     print(i)  # 结果13579
# 面试题
# for i in range(1,10,-1):
#     print(i)   # 答案：不会报错

#作业 循环打印这个列表，列表里的列表也要打印
li = [1,2,3,5,'jason',[6,7,8,'mason'],'taibai']
# print(type(li))
# print(len(li))
# 方法1
# for i in li:
#     if type(i) == list:
#         for k in i:
#             print(k)
#     else:
#         print(i)
# li = [1,2,3]
# s = str(li)
# print(s)
# 方法2
# for i in range(len(li)):
#     if type(li[i]) == list:
#         for j in li[i]:
#             print(j)
#     else:
#         print(li[i])

2.8: 字典

# dict
#数据类型划分
"""
不可变数据类型:元祖，bool,int,str， 可哈希
可变：list ,dict， set(集合） 不可哈希
dict key:必须是不可变数据类型，可哈希
dict value:任意数据类型
dict优点：二分查找法、储层大量的关系型数据
didt特点：无序的（python3.5之前的版本）

"""
# dic = {'name':['张三','李四  '],
#       'py9':[{'num':71,'avg_age':18}] ,
#        True:1,
#        (1,2,3):"数字",
#        2:4}
# print(dic)
# dic1 = {'name':'jason','age':18,'sex':'male'}
# 增加
# dic1['high'] = 175  # 没有键值对，添加，有一样的键值对，就覆盖了值
# dic1.setdefault('name','baozi')  #有一样的键值对，不做任何改变，没有才添加
# 删除
# dic1.pop('age')
# print(dic1.pop('age'))  # 有返回值，返回值是值
# print(dic1.pop('weight','None没有此键值对'))  # 如果没有被删除的对象，怕被误删除，可以用这个
# dic1.popitem()  # 随机删除
# print(dic1.popitem())  # 有范围值是一个元祖，删除的键和值
# clear 删除全部键值对
# dic1.clear()
# del dic1 删除字典
# 修改
# update
# dic2 = {'name':'baozi','weight':68}
# dic1.update(dic2)  # 把dic2跟新覆盖到dic1里面去，如果有一样的键就覆盖，没有就添加
# print(dic2)
# print(dic1)
# 查询
# print(dic1.keys(),type(dic1.keys()))
# print(dic1.values())
# print(dic1.items())

# for i in dic1.values():  # 什么都不写，打印的就是“键”
#     print(i)
# 面试题,用一行代码互换 ab的值
# a = 1
# b = 2
# a,b = b,a
# print(a,b)
# a,b = [1,2],['baozi',2]
# print(a,b)
# for k,v in dic1.items():
#     print(k,v)
# for i in dic1.items():
#     if type(i) == tuple:
#         for k in i:
#             print(k)
# print(dic1['name'])  # 输出值
# print(dic1['name1'])  # 没有对应的键就报错
# print(dic1.get('name'))
# print(dic1.get('name1','没有对应的键就提示'))  # 没有对应的键不会报错

# 字典的嵌套
# dic2 = {'name':['jason','mason','jerry'],
#         'py9':{'time':'1213',
#                'learn_money':19800,
#                'addr':'CBD'},
#         'age':21
#         }
# dic2['age'] = 56
# # 在‘name'中添加一个人名
# dic2 ['name'].append("dick")
# # 把mason大写，思路先修改字符串的大写，再修改name的列表
# dic2['name'][1] = dic2['name'][1].upper()
# # 在'py9'中增加一个女生的键值对 female 3人
# dic2['py9']['feamle'] = 3

# 作业 判断输入整数的个数
# info = input('请输入任意的字母和数字')  # fefeeegerh234rv12evbrbrbr789f66
# for i in info:  # 第一次的for，会把info的内容全部记下来,因为info是用户输入字符串，是不可变量。
#     if i.isalpha():
#         info = info.replace(i,' ')  # 这里info不断的复制，不会影响for里面的i的变化，这里的info不能改为new_info
# new_list = info.split()
# print(info)
# print(new_list)
# print(len(new_list))
# 分析上面的作业，为什么不能改为new_info
'''
# info = '11ab22ab33abc'
# info1 = info.replace('a', ' ')
# info2 = info1.replace('b', ' ')
# info3 = info2.replace('c', ' ')
# print(info1)
# print(info2)
# print(info3)
#结果
# 11 b22 b33 bc
# 11  22  33  c
# 11  22  33
info = '11ab22ab33abc'
info1 = info.replace('a', ' ')
info1 = info.replace('b', ' ')
info1 = info.replace('c', ' ')
print(info1)
#结果
# 11ab22ab33ab  结果就是最有一个C被空的覆盖了，如果把info1给为info就可以了

'''

 3，知识点小结和作业

# # 作业 li = [11, 22, 33, 44, 55, 66, 77, 88 ,99 ,90]    将li中的数字，比66小的放在一个字典的key中，比66大的放在另一个key中
# li = [11, 22, 33, 44, 55, 66, 77, 88, 99,90]
# li1 = []
# li2 = []
# dic = {'key1':[],'key2':[]}
# for i in li:
#     if i > 66:
#         li1.append(i)
#     if i < 66:
#         li2.append(i)
# dic['key1'] = li1
# dic['key2'] = li2
# print(li1)
# print(dic)
# 购物车作业
'''
输出商品列表，用户输入序号，显示用户选中的商品
商品 li = ['手机','电脑','鼠标垫','游艇']
要求：1，页面显示 序号 + 商品名称
2，用户输入选择的商品序号，然后打印商品名称
3，如果用户输入的商品序号有误，提示错误，并重新输入
4，用户输入Q或者q,退出循环
'''
# commodity = ['手机','电脑','鼠标垫','游艇']
# while 1:
#     for i in commodity:
#         print('{}	{}'.format(commodity.index(i)+1,i))
#     buy = input("请选择你需要了解的产品序号/Q退出：")
#
#     if buy.isdigit():
#         buy = int(buy)
#         if buy > 0 and buy <= len(commodity):
#             print('你已经选择的商品：{}'.format(commodity[buy-1]))
#         else:
#             print('你输入的序号有误，请重新输入')
#     elif buy.isalpha() and buy.upper() == 'Q':
#         print('退出本次服务')
#     else:
#         print('你输入的有效的序号，请重新输入')

#
# = 赋值  == 比较是否相等   is 比较  比较的是内存地址 id()
# li1 = [1,2,3]  # 在内存中创建了一个空间，空间里面有一个[1,2,3]的列表，列表的内存地址是a
# li2 = li1  # 赋值运算,li1和li2指向同一个列表，内存地址也是a
# li3 = [1,2,3]  # 在内存中创建了一个空间，空间里面有一个[1,2,3]的列表，列表的内存地址是b
# print(li1 is li2)  # 结果为True
# print(id(li1))  # 结果为内存地址a
# print(id(li2))  # 结果为内存地址a
# print(id(li3))  # 结果为内存地址b

# 分类：数字、字符串  小数据池：在一个范围之内，在内存中共用一个内存地址，为了节省内存
# 数字的范围：-5到256 ，只有数字和字符串才有小数据池概念，其他的都没有
# i1 = 6
# i2 = 6
# print(id(i1),id(i2))  # 结果是一样的，小数据池
# i3 = 6000
# i4 = 6000
# print(id(i3),id(i4))  # 这里的结果是一样的，如果换python的版本，结果不一样的
# 字符串，小数据池：1，不能含有特殊字符  2,s*20 是同一个，s*21不是同一个
# i1 = 'a'*20
# i2 = 'a'*20
# print(id(i1),id(i2))  # 结果是一样的，小数据池
# i3 = 'a'*21
# i4 = 'a'*21
# print(id(i3),id(i4))  # 这里的结果是不一样的

 3.1 ：购物车作业

#print(commodity.count('电脑'))
shopping_troley = {}
need_money = 4500
print('欢迎光临')
your_money = input('请输入你目前的余额：')
your_money = int(your_money)
while 1:
    commodity = [{'name': '手机', 'price': 2000, 'quantity': 100},
                 {'name': '电脑', 'price': 5000, 'quantity': 100},
                 {'name': '充电器', 'price': 50, 'quantity': 100},
                 {'name': '手机外壳', 'price': 35, 'quantity': 100}]

    if your_money >= need_money:
        print('-'*40)
        print('序号','名称','价格','剩余数量')
        print('-'* 40)
        for i in commodity:
            print('{}	{}	{}	{}'.format(commodity.index(i)+1,commodity[commodity.index(i)]['name'],commodity[commodity.index(i)]['price'],commodity[commodity.index(i)]['quantity']))
        choice = input('请选择加入购物车的商品序号/Q退出：')

        if choice.isdigit():
            choice = int(choice)
            if choice > 0 and choice <= len(commodity):


                num = input('请输入你要购买的数量：')
                if num.isdigit() and int(num) < commodity[choice -1]['quantity']:
                    your_money = your_money - commodity[choice-1]['price']*int(num)
                    #print(commodity[choice-1]['quantity'])  # 测试剩余数量
                    commodity[choice-1]['quantity'] = commodity[choice-1]['quantity'] - int(num)
                    print(commodity[choice - 1]['quantity'])
                    print('剩余金额：{}'.format(your_money))
                    if commodity[choice-1]['name'] in shopping_troley:
                        shopping_troley[commodity[choice-1]['name']] = int(num) + shopping_troley[commodity[choice-1]['name']]
                        print(shopping_troley)
                    else:
                        shopping_troley[commodity[choice-1]['name']] = int(num)

                    print('你已经选择以下商品：
','-'*40)
                    print('{}
余额：{}元'.format(shopping_troley,your_money))
                        #print('你选择的购物车的商品：{}'.format(shopping_troley))
                else:
                    print('库存数量不足，请重新输入你要购买的数量')
            else:
                print('你输入的正确的商品序号，请重新输入')
        elif choice.upper() == 'Q':
            print('你已经选择结束本次服务')
            break
        else:
            print('请输入正确的内容')
    else:
        print('你太穷了，下个月发了工资在来吧')
        break

4，集合

# 集合：可变的数据类型，但里面的元素必须是不可变的数据类型，无序，不重复
# set1 = set({1,2,3})  # 创建方式1
# print(set1)
# set2 = {1,2.3,}  # 创建方式2
# print(set2)

# 增加
# set1 = {'jason','mason','mason','jack'}   # 如果有重复的元素，会自动删除一个的，打印出来只有一个mason
# add 增加
# set1.add('女神')
# # update 增加 迭代增加
# set1.update('dick')  # {'k', 'c', 'd', 'mason', 'i', 'jason', '女神'}

# 删除
# pop 随机删除 有返回值
# set1.pop()
# print(set1.pop())
# remove 按照元素删除
# set1.remove('jason')  # 元素不对会报错
# clear 清空集合
# set1.clear()
# del 删除集合
# del set1

# 查询，没有修改的
# for i in set1:
#     print(i)

# 交集
# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
#set3 = set1 & set2 交集方法1
# set3 = set1.intersection(set2)  # 交集方法2
# print(set3)

# 并集
# set3 = set1 | set2  # 并集方法1
# set4 = set1.union(set2)  # 并集方法2

# 反交集
# set3 = set1 ^ set2  # {1, 2, 3, 6, 7, 8}
# set4 = set1.symmetric_difference(set2)   # {1, 2, 3, 6, 7, 8}

# 差集，set1独有的元素
# set3 = set1 - set2   # {1, 2, 3}
# set4 = set1.difference(set2)   # {1, 2, 3}

# 子集和超集
# set1 = {1,2,3}
# set2 = {1,2,3,4,5,6}
# print(set1<set2)   # 返回True 说明set1是set2的子集
# print(set1.issubset(set2))
# print(set2.issuperset(set1)) # 返回True，说明set2是set1的超集

# frozenset 让集合变成不可变类型
# set1 = frozenset('jason')
# print(set1,type(set1))  # frozenset({'s', 'a', 'o', 'n', 'j'}) <class 'frozenset'>

# 面试题
# 去掉重复的元素
# li = [1,2,33,33,2,1,4,5,6,6]
# set_li = set(li)  # 列表转换为集合
# li = list(set_li)  # 集合转换为列表
# print(set_li)
# print(li)

#面试题
# 删除列表的奇数位，即 2 ，4这两个元素
# li = [1,2,3,4,5]
# num = (len(li)-1)/2
# # print(num)
# for i in range(len(li)):
#     i = i + 1
#     del li[i]
#     if i >= num:
#         break
# print(li)

# dic = {'k1':'v1',
#        'k2':'v2',
#        'a3':'v3'}
# 方法1：这种解法报错，不能再字典for循环中删除元素
# for i in dic.keys():
#     print(i)
#     if 'k' in i:
#         del dic[i]
# 方法2：
# dic1 = {}
# for i in dic:  #dic后面不带，就是默认的keys
#     print(i)
#     if "k" not in i:
#         dic1.setdefault(i,dic[i])
# dic = dic1
# print(dic)
# 方法3：
# li = []
# for i in dic:
#     if 'k' in i:
#         li.append(i)
# print(li)
# for i in li:
#     del dic[i]  # 不能再for字典中直接删除，转到列表循环中删除
# print(dic)

# 注意，在字典和列表用for循环中，不要删除里面的东西，会很麻烦

# 元祖，如果元祖里面只有一个元素且不加逗号，这元素本来是什么数据类型，就是原来的数据类型
a = (1)  #1 <class 'int'>
b = (1,)  # (1,) <class 'tuple'>

 4.1:集合的作业

# 作业讲解
#lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
# 把'tt'变成大写
#lis[0][1][2]['k1'] = ['TT',3,'11']
#lis[0][1][2]['k1'][0]= lis[0][1][2]['k1'][0].upper()
# 将列表中的数字3变成字符串‘100’
#lis[0][1][2]['k1'][1] ='100'
#将列表中的字符串‘1’变成数字100
# lis[0][1][2]['k1'][2] = 101
# print(lis)

# dic = {'k1':'v1','k2':['alex','sb'],(1,2,3,4,5):{'k3':['2',100,'wer']}}
# k2对应的值后面加一个‘23’
#dic['k2'].append('23')
# k2对应的值第一个位置加一个‘a’
# dic['k2'].insert(0,'a')
#将（1，2，3，4，5）对应的值添加一个键值对‘k4':'v4'
# dic[(1,2,3,4,5)].setdefault('k4','v4')
#将（1，2，3，4，5）对应的值添加一个键值对(1,2,3):'ok'
# dic[(1,2,3,4,5)].setdefault((1,2,3),'v4')
#将’k3'对应的值‘wer'改为’gg'
# dic[(1,2,3,4,5)]['k3'][2] = 'gg'

# li = ['alex','wusir','rain']
# 将列表转换为字符串'alexwusirrain'
# li = ''.join(li)
# 将列表转换为字符串'alex*wusir*rain'
# li = '*'.join(li)
# 将字符串'alexwusirlex'转为列表['a','exwusirlex']
# s = 'alexwusirlex'
# li = s.split('l',1)
# 将字符串'alex wusir'转为列表['alex','wusir']
# s = 'alex wusir'
# li = s.split(' ')
# 将字符串'alex'转为为'a l e x'
# s =  'alex'
# s1 = ' '.join(s)
# print(s1)

# 用for循环打印1-2+3-4，，+99的结果
# sum = 0
# for i in range(1,100):
#     if i%2 != 0:
#         sum = sum + i
#     if i%2 == 0:
#         sum = sum - i
# print(sum)

# 用rang打印100，99，98，，，1，0
# for i in range(100,-1,-1):  # 最后的-1是步长
#     print(i)

#计算用户输入内容中索引为奇数并且对应的元素为数字的个数
# s = input('请输入内容：')
# count = 0
# for i in range(len(s)):
#     if i % 2 == 1 and s[i].isdigit():
#         count += 1
# print(count)

#大于66的放在字典的第一个key值里面，小于66的放在字典的第二个key值里面
# li = [11,22,33,44,55,77,88,99,90]
# dic = {}
# for i in li:
#     if i > 66:
#         if 'k1'not in dic:
#             dic['k1'] = []
#         dic['k1'].append(i)
#
#     if i < 66:
#         if 'k2'not in dic:
#             dic['k2'] = []
#         dic['k2'].append(i)
# print(dic)

# 加法计算器
# content = input('请输入内容：')
# dic = {'最终计算结果':None}
# li = content.split("+")
# sum = 0
# for i in li:
#     sum = sum + int(i)
# dic['最终计算结果'] = sum
# print(dic)

#模拟公司hr录入员工账号密码的程序，每次添加成功，打印出来名字和密码
# user_list= [{'username':'barry','password':'1234'},
#             {'username':'alex','password':'asdp'}]
# #非法字符模板，如有非法字符，替换成*
# board = ['张三','李小四','王二麻子']
# while 1:
#     name = input("请输入员工的名字：")
#     if name in board:
#         name = '*'*len(name)
#     elif name.upper() == 'Q':
#         break
#
#     psw = input('请输入%s的密码：'%name)
#     user_list.append({'username':name,'password':psw})
#     print('添加成功，账号：{},密码：{},退出Q'.format(name,psw))