Python笔记

一、数据类型

1.基础

0渔：（ **kwargs） 传：1. name = ...
                     2. 字典 **{，，，，}
（ *args）  可变长度的列表（元祖）
（ **kwargs） 可变长度的字典
*[] 遍历元素

print 默认换行，如需取消，可更改为 print('aaa',end = '\t')

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

变量：
    1.变量只是一个门牌号，无任何实际意义
    2.同样的值不会被创建多次，再有变量则直接指向它

一、基本数据类型：
    python 函数中 start、end：均为 [ ) ，从0开始

1.字符串 str ：(11个魔法)

    #字符串一经创建不可修改，所有修改和拼接都产生新的字符串（在内存中连续）
	1. 加法：组合
	2. 乘法：重复n次
	3. input() 接收到的都是字符串
	4. int() 可将字符串强制转换成数字
	5. str() 可将某数据类型强制转换成字符串    -- 只在外面加了 ''
	6. in 和 not in 成员运算符
    ################### 7个基本魔法 ##################
	join replace split(不保留分割) find strip(去除) upper lower
	-- 首字母大写  .capitalize()
	-- 变小写  casefold   lower
	-- 变大写  upper
	-- 大小写 翻转 swapcase
	-- 在某长度居中 center
	-- 放左边 ljust
	-- 放右边 rjust
	-- 去除 （前面后面）所有空格、\n、\t（或指定字符，放括号里传进去）  strip、lstrip、rstrip
	-- 子字符串 在原字符串中有几个 count
	-- 判断开头、结尾 startswith endswith
	-- 索引子字符串位置  index find
	-- 格式化 format  将字符串中占位符{xx} 赋值  ,, 用法还挺多（模板输出必用！方便！）
	    -- 赋值法
	        -- test = '可爱的{name}最喜欢在{location}干{hobby}'
	        -- test.format(name = name, location = location,hobby = hobby)
	    -- 顺序法
	        -- test = '可爱的{}最喜欢在{}干{}'
	        -- .format(name,location,hobby)
	-- 判断是否全是 字母/汉字 、数字 isalnum
	-- 判断是否全是 字母/汉字 isalpha
	-- 判断是否全是 数字      isdigit   isdecimal 还一个
	-- 判断是否存在 特殊\n \t 字符  isprintable
	-- 判断是否全是空格 isspace
	-- 制表  expandtabs()  将制表符 展开为n个空格
	    -- 最后加，巨他妈方便！ 将 \t 填充为 你想要的多少个空格
 ★ -- join- 将..拼接符 插入字符串之间 (产生新的，需要用新变量存储，原来字符串的统统不变)  join
	-- 字符替换 之 replace
	    -- test.replace('aa','11',2)
	        # 将'aa'替换为'11'，只替换前2个，默认为替换全部
	        # 一次只能替换1种

	-- 字符替换 之 translate
	    --先创建翻译法则 m = str.maketrans('aeiou','12345')
	    --再按照法则翻译 v = test.translate(m)
	-- 字符串分割
	    -- 普通分割
	          partition('s') 按第一个's'分割成3份    （'s'保留）
	         rpartition('s') 按倒数第一个's'分割成3份（'s'保留）
	          split('s'，8)  从左往右找8个's'进行分割（'s'不保留）(不传个数时，默认分割所有's')
	          -- 超级方便的接受方法：v1,v2,..., = test.split('f')
	         rsplit('s'，8)  从右往左找8个's'进行分割（'s'不保留）
	    -- 按行分割
	        splitlines（True/False用于选择是否保留换行，钉在前面）

    ##################### 5个灰魔法 ######################

    -- 索引
        [3]    第4个元素
    -- 切片   [ )（左闭右开） 结果仍为字符串而非元素--字符
        [0:3]   第1-3 个
        [0:-1]  第1-最后(-1不包括)
        [2: ]  第3个 - 最后全部
    -- 获取长度
         len(test)  或   .len()
        （字符串长度 / 元素个数）
    -- for循环
        for A in test :
            print(A)
    -- range
        用于创建连续的数字，或固定步长的数字
        range(100)  : 0,1,2,...,99
        range(1,100) : 1,2,3,...,99
        range(0,100,5) :  0,5,10,..,95
        range(100,0,-1) :  从后往前

2.数字 int ：
	1. 次方：**
	2. 取余：% （可用于判断奇偶数）
	3. 取商：//
	4. 加法求和时用 sum1 ， 防止覆盖掉sum()函数功能

	################## 数字的 方法 #################

	1. bit_length()     获取数字占了几位

3.布尔值 bool ：
    1.True False
        -- True : '有东西' 、 数字不为0
        -- False : '   '  、  0

    2.开头必须大写

4.列表 list :
-- li = [ 1,2,'a','b', [1,'a'] ,2 ]
    1.元素也可为列表，子列表整体为一个元素
    2.可用 [ ：] 切片 ，得到的结果仍为列表
        取最后一个：[-1]
    3.支持 for循环、while循环 ： 遍历每个'元素'
    4.支持 in 操作，查找元素
    4.修改：列表可被修改（内存中可不连续地存）
        -- 不可修改： 数字，字符串，元祖
        -- 可修改：  列表，字典，数组，集合
    5.删除：del
    6.强制转换：list('asdf')
        -- ['a','s','d','f']
    7.列表->字符串：
        1.列表元素都是字符串：
            -- ''.join(li)
        2.列表元素有数字：
            -- 写for循环，v = v + str(s)

    ############### list类：方法 （list可修改，不可用新变量接收）#################
 ★ 1. li.append('ss')
            -- 将'ss'整体 追加为列表最后一个元素
    2. li.clear()
            -- 清空列表
    3. li.copy()
            -- 浅拷贝
            -- v = li.copy()
    4. li.count('ss')
            -- 计数元素'ss'有几个
 ★ 5. li.expand(可迭代对象-- 如：列表，字符串)
            -- 扩展列表（取可迭代对象里的元素）
    6. li.index('ss')
            -- 索引元素下标（位置），找到第一个就结束
            -- 可传入 start、end 来圈定区间
 ★ 7. li.insert(2,'ss') 下标，值
            -- 插入元素至指定位置
    8. li.pop(下标)
            -- 删除，缺省默认删除最后一个元素
            -- 传入下标，删除指定位置的元素
            -- 可接收所删除的元素的值 v = li.pop()
    9. li.remove('ss')
            -- 删除指定的元素，找到第 一个就结束
            -- 不可缺省,不可接收
    #### 删除 ####
    #### pop remove del clear ####
    10. li.reverse()
            -- 翻转，将列表元素顺序翻转
    11. li.sort()
            -- 排序，缺省：从小到大对元素排序
            -- （ reverse = True ）：从大到小排
            -- 列表元素类型必须全是数字


5.元祖 tuple ：
    -- tu = ( 11,'ss',[],(),22,33 , )
    -- 有序，可理解为不可修改的列表 -- 元祖的一级元素不可被 修改、增加、删除
                               -- 二级或更高的可以被修改
    -- 想修改时可 与 list灵活转换
    1. 支持 索引、切片
    2. 支持 for循环
    3. str list tuple 三个可迭代对象 ：可互相强制类型转换，join可用

    ######### 方法 #########
    1. tu.count('ss')
        -- 计数元素 'ss' 有几个
    2. tu.index('ss')
        -- 索引元素 'ss' 位置


6.字典 dict ：     按哈希表保存
    -- dic = {
        'v1' : 'k1' ,  # 键值对
        'v2' : 'k2'
        }
    -- 无序，可修改
    -- 字典的key 不可以是 ：列表 字典
    -- 字典的value ：任何值都可以

    -- 索引：(取值)
        -- v = dic['v1']
        -- 结果：v =
        -- 若没有，报错
    -- 删除：
        -- del:
            -- del dic[key]
    -- 不支持 while 循环
    -- 支持 for 循环
        -- 循环下一级key：
            -- for i in dic:
            -- for i in dic.keys() :
        -- 循环下一级value：
            -- for i in dic.values() :
        -- 循环下一级键值对：
            -- for i,j in dic.items() :

    ################### 字典的 方法 ###################
    重要：keys values items get update
    #### 普通方法 ####
    1. dic.clear()
        -- 清空
    2. dic.copy()
        -- 浅拷贝
 ★ 3. dic.get(key,若没有返回的值)
        -- 索引取值
        -- 若没有，不报错，返回指定值
 ★ 4. dic.keys()  dic.values()  dic.items()
        -- 返回所有信息，为特殊类型，类似于可循环的列表
    5. dic.pop(key,若没有返回的值)
        -- 删除key对应的值
        -- 所删除的值可用 v= 接收
        -- 若没有，不报错，返回指定值
    6. dic.popitem()
        -- 随机删一个键值对
    7. dic.setdefalt(key,value)
        -- 设置一个新键值对的默认值（可理解为添加一个键值对）
        -- 若该key已存在，则不再设置
        -- 可用 v= 接收到该key对应的当前值
 ★ 8. dic.update(键值对或字典)
        -- 更新字典元素
        -- 无则添加，有则覆盖
        -- 第二种写法（ key1=value1, key2=value2 ）

    #### 静态方法 ####
    1. dict.fromkeys(序列，value)
        -- 创建字典，{
                      序列的每个元素 ：统一的值
                      序列的每个元素 ：统一的值
                      ...
                    }
        -- 序列可为: 列表、字符串 等




######################## 整理 ###########################

一、数字
    1. int()

二、字符串
    1. replace find join strip split startswith upper format

三、列表
    1. append extend insert
    2. 索引 切片 循环

四、元祖（不可修改的列表）
    ★ 一级元素不能被修改 增加 删除
    1. count index 都不重要
    2. 索引 切片 循环

五、字典（键不可修改，值可修改）
    ★ 无序不能切片，可修改
    1. get update keys values items
    2. for循环 索引

六、布尔值

    1. bool（）
    2. False值：0 None '' [] () {}


######################## 变量、数据类型 总结 ###########################

-- 是否可变：
1.可变：列表，字典
2.不可变：字符串，元祖

-- 访问顺序：
1.顺序访问：字符串，列表，元祖
2.映射访问：字典（访问速度快，但占用内存多）

-- 存放元素个数：
1.原子类型：数字，字符串
2.容器类型：列表，元祖，字典




二、逻辑：
1.条件：
	1. 要加冒号
	2. elif：
	3. and 与 or 优先级一样，严格按照先后顺序执行
2.循环：(也要加冒号)
	1. 死循环：while True：
	2. 循环10次：
	
		count = 0
		while count <10 :
			count +=1

			...
			...
			
3. continue后的内容不执行，可用于跳过某个特殊条件
4. break 跳出循环

2.补充

####### 知识点 #######

# 1. 输入输出

'''
name = input ('ID:')
password = input('PassWord:')
print("hello world !")
'''

# 2. 数字

'''
a1 = 2
a2 = 3
a3 = a1 / a2
a4 = a1 ** a2
a5 = a2 % a1
print( '除法：' , a3 , '\n' 	+	'次方：', a4 , '\n' 	+	'取余：' , a5 , '\n' )	# 最好直接写3个 print()	
'''

######## 练习题 #######


# 考点：
# 1. if条件语句
# 2. while循环
# 3. 奇偶数


# 1. 使用while循环输出 123456 8910

'''
count = 0
while count < 10 :
	count += 1		 	# 先写，容易忘（此时，count已经+1了,相当于从1开始）
	if count != 7 :
		print(count)
	else :
		pass
'''

# 2. 求1-100所有数的和

'''
count = 0
sum1 = 0
while count < 100 :
	count += 1
	sum1 = sum1 + count
print(sum1)
'''	

# 3. 输出1-100所有奇数
'''
count = 0
while count < 100 :
	count += 1
	if count % 2 == 1 :
		print(count)
'''	

# 4. 输出1-100所有偶数

'''
count = 0
while count < 100 :
	count += 1
	if count % 2 == 0 :
		print(count)
'''

# 5. 求1-2+3-4+5...99

'''
count = 0
sum1 = 0
while count < 99 :
	count += 1
	if count % 2 == 1 :
		sum1 = sum1 + count
	else :
		sum1 = sum1 - count
print(sum1)
'''
	
# 6. 用户登录（三次机会）

'''
count = 0
while count < 3:
	count += 1
	id = input ('please input your id:')
	password = input ('please input your password:')
	if id == 'shendaw' and password == '163':
		print ('login successful!')
		break
	else :
		print ('login failed!')
'''


################### 字符串 ####################

################ 练习题 ###############
# 例题 . 用户输入字符串，打印其每个字符及其对应的索引
# 题眼：以len作为range
'''
test = input('>>>')
for i in range(len(test)) :
    print(i,test[i])
'''
### 1.执行 python 脚本的2种方式

# -- 1. 编辑好文件后 运行文件
# -- 2. python 解释器 现场交互 写一句运行一句


### 2. 简述 位、字节 的关系

# -- 1字节 = 8位


### 3. 简述 ascii unicode utf8 gbk 关系

# -- ascii : 1字节 （7位 0-126）
# -- unicode : 万国码 字符集 至少2字节
# -- utf8 ：Unicode压缩版 编码规则 汉字3字节
# -- gbk ：汉字编码规则 2字节

### 10. 字符串操作

# a. 移除两头空格
'''
name = '  aleX'
v = name.strip('a')
print(v)
'''
# b. 判断开头是否为 al
'''
name = 'aleX'
v = name.startswith('al')
print(v)
'''
# c. 判断结尾是否为 X
'''
name = 'aleX'
v = name.endswith('X')
print(v)
'''
# d. 将 l 替换为 p
'''
name = 'aleX'
v = name.replace('l','p')
print(v)
'''
# e. 根据 l 分割 (分割后变为列表类型)
'''
name = 'aleX'
v = name.split('l')
print(v,type(v))
'''
# f. 变大写
'''
name = 'aleX'
v = name.upper()
print(name,v)
'''
# g. 变小写
'''
name = 'aleX'
v = name.lower()
print(name,v)
'''
# h. 输出第2个字符
'''
name = 'aleX'
v = name[1]
print(name,v)
'''
# i. 输出后2个字符
'''
name = 'aleX'
v = name[-2:]
print(v)
'''
# j. 输出 e 下标
'''
name = 'aleX'
v = name.find('e')
print(v)
'''
# k. 获取子序列，仅不包含最后一个字符
# 法一：
'''
name = input('>>>')
v = name[:-1]
print(v)
'''
# 法二：
'''
name = input('>>>')
l = len(name)
for i in range(0,l-1) :
    print(name[i])
'''

### 21. 字符串是否可迭代，如是，用for循环
'''
name = input('>>>')
for i in name :
    print(i)
'''

### 22. 用下划线 连接 字符串里的字符
'''
name = input('>>>')
v = '_'.join(name)
print(v)
'''

### 22. 用下划线 连接 列表里的元素
'''
name = ['sfdsdf','asfd','safggs']
v = '_'.join(name)
print(v)
'''

### 23. range 在 python2 和 python3 里的区别：

# python2 里 ： 直接全部创建在内存里
# python3 里 ： 循环时才一个一个创建
'''
    for i in range(100,0,-1):
        print(i)
'''

### 24. 整数加法计算器：
'''
n = input('>>>')
l = n.split('+')
n1 = int( l[0].strip() ) 
n2 = int( l[1].strip() )
re = n1 + n2
print(l,re)
'''

'''
test = 'sdkflslkfjsslk'
v = test.split('s',1)
print(v)
'''


### 25. 统计 数字 、 字母 个数：

'''
num = 0
alpha = 0
test = input('>>>')
for i in test :
    if i.isdecimal() :
        num += 1
    if i.isalpha():  
        alpha += 1
print(num,alpha)
'''

### 27. 制作模板
'''
name = input('name:')
location = input('location:')
hobby = input('hobby')
result = '可爱的' + name + '最喜欢在' + location + '干' + hobby
print(result)
'''

'''
name = input('name:')
location = input('location:')
hobby = input('hobby:')

result = '可爱的{0}最喜欢在{1}干{2}'
result = result.format(name,location,hobby)
print(result)
'''

### 28. 制作随机验证码，不区分大小写




### 29. 过滤敏感词汇
'''
test = input('>>>')
new = test.replace('苍老师','***')
new = new.replace('东京热','***')
print(new)
'''

### 30. 制作表格 ，循环输入，检测到输入为 q 或 Q 停止录入，超过20字符以20个计
'''
result = 'name:\t'.expandtabs(25) + 'password:\t'.expandtabs(25) + 'email:\t\n'.expandtabs(25)
while True :

    name = input('name:')[:20] + '\t'
    if name.strip().lower() == 'q' :
        break
    name = name.expandtabs(25)

    password = input('password:')[:20] + '\t'
    password = password.expandtabs(25)

    email = input('email:')[:20] + '\t\n'
    email = email.expandtabs(25)

    result = result + name + password + email

print(result)
'''

# 改进！牛逼！用了模板format 和 expandtabs最后加 ！！！
'''
template = '{}\t {}\t {}\t\n'
result = template.format('name:','password:','email:')
while True :
    name = input('name:')[:20]
    if name.strip().lower() == 'q' :
        break
    password = input('password:')[:20]
    email = input('email:')[:20]
    result = result + template.format(name,password,email)
    result = result.expandtabs(25)
print(result)
'''

3.总习题20个

################# 1. 用 下划线 将列表元素拼接为一个字符串

# li = ['a','b','k']
# v = '_'.join(li)
# print(v)

################# 3. 列表操作

# li = ['a','b','k']
# del li[2]
# print(li)

################ 5. 元祖操作
# 1.计算元祖长度并输出
# 2.获取元祖第二个元素并输出
# 3.获取1-2个元素并输出
# 4.for循环输出元素
# 5.for,len,range输出元祖索引
# 6.enumrate输出元素和序号(序号10开始)

# tu = ('a','b','c')
# v = enumerate(tu,10)
# for i,j, in v :
#     print(i,j)

################ 6. 元祖操作

# tu = ('alex',[11,22,{'k1':'v1','k2':['age','name'],'k3':(11,22,33)},44])
#
## tu[1][2]['k2'].append('seven')
# tu[1][2]['k3']=(111111)
#
# print(tu)



######################################### 10. 输出商品列表
# 用户输入序号,显示用户选中的商品
# 商品 li = ['手机','电脑','鼠标','键盘']
# 要求: 允许用户添加商品

# li = ['手机','电脑','鼠标','键盘']
# while True:
#     for i in range(len(li)) :
#         print(i,li[i])
#     n1 = input('please choose what you want:')
#     if n1.isdecimal() : # 判断格式是否正确
#         n1 = int(n1)    # 强制转换为数字
#     else :
#         print('the content format is wrong,please enter again!')
#         continue
#     print('the item you selected:', li[n1])
#
#     n2 = input('please input the item you want to add:')
#     if n2 != '' :   # 用户输入的 n2非空，才添加
#         li.append(n2)

############################################## 11. 用户交互显示 n级联动选择
# 如: 省市县
# 要求: 允许用户增加内容
# 南京市 = [1,2,3]
# 宿迁市 = [4,5,6]
# 杭州市 = [7,8,9]
# 金华市 = [10,11,12]
#
# 江苏省 = [南京市,宿迁市]
# 浙江省 = [杭州市,金华市]
#
# 中国 = [江苏省,浙江省]
# for i in 中国 :
#     print(i)
       
# 1. 字典法：
dic = {
         '江苏省':{
                    '南京市':[1,2,3],
                    '苏州市':[4,5,6],
                    '宿迁市':[7,8,9]
                 },
         '浙江省':{
                    '杭州市': [1,2,3],
                    '金华市':[4,5,6]
                 },
         '广西省':{
                    '南宁市': [1,2,3],
                    '桂林市':[4,5,6],
                    '贵港市':[7,8,9]
                 }
}

province = input('输入省：')
for i in dic[province]:
    print(i)

city = input('city:')
for i in dic[province][city]:
    print(i)


############################################## 12. 列举布尔值是 False的所有值

# 0 '' False
# [] () {}
# None

# #################################### 13. 对 2个列表：
#     l1 = [11,22,33]
#     l2 = [22,33,44]
#     a. 获取内容相同的元素列表
#     b. l1有，l2没有的元素列表
#     c. l1没有，l2有的元素列表
#     d. 获取内容都不相同的元素

# l1 = [11,22,33]
# l2 = [22,33,44]
# v = []
# for i in l1 :
#     if i in l2:
#         v.append(i)
# print(v)

# l1 = [11,22,33]
# l2 = [22,33,44]
# v = []
# for i in l1 :
#     if i not in l2:
#         v.append(i)
# print(v)

# l1 = [11,22,33]
# l2 = [22,33,44]
# v = []
# for i in l2 :
#     if i not in l1:
#         v.append(i)
# print(v)

# l1 = [11,22,33]
# l2 = [22,33,44]
# v = []
# for i in l1 :
#     if i not in l2:
#         v.append(i)
# for i in l2 :
#     if i not in l1:
#         v.append(i)
# print(v)  18.48

########################################## 14. 利用 for循环和range输出：
#     a. for循环从大到小输出 1 - 100
#     b. for循环从小到大输出 100 - 1
#     c. while循环从大到小输出 1 - 100
#     d. while循环从小到大输出 100 - 1

# for i in range(1,101) :
#     print(i)

# for i in range(100,0,-1) :
#     print(i)

# count = 0
# while count < 100 :
#     count += 1
#     print(count)

# count = 101
# while count >1 :
#     count -= 1
#     print(count)

####################################################### 15. 购物车
#     功能要求：
#         要求用户输入总资产
#         显示商品列表，用户根据序号选择商品加入购物车
#         购买，若商品总额大于资产余额不足，否则购买成功
#     goods = [
#         {'name':'电脑'，'price':1999}
#         {'name':'鼠标'，'price':10}
#         {'name':'键盘','price':20}
#         {'name':'老婆'，'price':998}
#     ]

# goods = [
#     {'name': '电脑', 'price': 1999},
#     {'name': '鼠标', 'price': 10},
#     {'name': '键盘', 'price': 20},
#     {'name': '老婆', 'price': 998}
# ]
# for i in goods :
#     n = goods.index(i)
#     print(n,i)
# n1 = input('输入资产：')
# n1 = int(n1)
# n2 = input('输入编号：')
# n2 = int(n2)
# if n1 >= goods[n2]['price'] :
#     print('purchase success!')
# else :
#     print('insufficient balance!')

######################################## 16. 分页显示内容
# a. 通过for循环创建301条数据，数据类型不限，如：
#     alex-1      alex1@live.com      pwd1
#     alex-2      alex1@live.com      pwd1
#     alex-3      alex1@live.com      pwd1
#     alex-4      alex1@live.com      pwd1
#     ...
# b. 提示用户输入页码，显示该页数据
#
# 注意：每页显示10条数据
#     若输入的不是十进制数字则提示格式错误

# 1.字符串模板法：
# template = 'alex-{}\t alex{}@live.com\t pwd{}'
# test = []
# for i in range(1,302) :
#     v = template.format(i,i,i)
#     test.append(v)
# n1 = input('page:')
# n1 = int(n1)
# for i in range(10*n1-10, min(10*n1,301) ) :
#     print(test[i])

# 2.字典法：
# li = []
# for i in range(301):
#     temp = {'name':'alex'+str(i),
#             'email':'alex'+str(i)+'@163.com',
#             'pwd':'pwd'+str(i)
#             }
#     li.append(temp)
# page = input('page:')
# page = int(page)
# for i in range((page-1)*10,min(301,page*10)) :
#     print(li[i])

################################################# 17. 数字 1，2，3，4，5，6，7，8
# 能组成多少个互不相同且无重复数字的 2位数

# li = [1,2,3,4,5,6,7,8]
# count = 0
# for i in li :
#     for j in li :
#         if i != j :
#             count += 1
# print(count)

################################################ 18. 用 for循环和range输出 9*9 乘法表

# str0 = ''
# for j in range(1,10) :
#     for i in range(1,10):
#         if i <= j :
#             r = i*j
#             str0 += str(i)+'*'+str(j)+'='+str(r)+'\t'
#     print(str0)
#     str0 = ''


# for j in range(1,10) :
#     for i in range(1,10):
#         if i <= j :
#             r = i*j
#             print(i,'*',j,'=',r,end = '\t')
#     print('')



################################################ 19. 找出一列表中任 2元素相加 =9的元素集合 [(4,5),(3,6)]

# nums = [2,7,11,15,1,8,7]
# r = []
# for i in nums :
#     for j in nums :
#         if i!=j and i+j == 9 :
#             r.append((i,j))
# print(r)

############################################### 20. 百钱买百鸡
# 公鸡1只 5元
# 母鸡1只 3元
# 小鸡1只 1/3元
# 要求：100元买100只鸡，三种都要有
# 问：各买几只？

# for a in range(1,20) :
#     for b in range(1,67) :
#         for c in range(1,98) :
#             if 5*a + 3*b + c/3 == 100 and a+b+c == 100 :
#                 print((a,b,c))

4.集合

1.集合：(set : 可变，不可修改)
        (frozenset : 不可变集合)
    1.无序
    2.元素必须是不可修改类型
    3.元素不同（相同的元素无效）

2.应用：
    简单去重：(会打乱顺序)
        强制转换为集合，再转换回去

3.set方法：

    1. 添加1个元素
        -- s.add()

    7. 添加多个元素
        -- s1.update([1,2,3])

    2. 清空
        -- s.clear()

    3. 拷贝
        -- s.copy()

    4. 删除(随机删一个元素)
        -- s.pop()

    5. 删除（指定元素）(不存在会报错)
        -- s.remove('s')

    6. 删除（指定元素）（不会报错）
        -- s.discard('s')

    7. 取交集
        -- s3 = s1 & s2
        -- s3 = s1.intersection(s2)

    8. 取并集
        -- s3 = s1 | s2
        -- s3 = s1.union(s2)

    9. 取差集(s1 - 相同部分)
        -- s3 = s1 - s2
        -- s3 = s1.difference(s2)

    10. 交叉补集（s1+s2-相同部分）(互不相同部分)
        -- s3 = s1 ^ s2
        -- s3 = s1.symmetric_difference(s2)

    11. 判断有无交集
        -- v = s1.isdisjoint(s2)

    12. 判断s1是否为s2子集
        -- v = s1 <= s2
        -- v = s1.issubset(s2)

    13. 判断s1是否为s2父级
        -- v = s1 >= s2
        -- v = s1.issuperset(s2)

二、字符串格式化

一、% 方法


    s = 'i am %s , my age is %d'  %('shendaw',22)

        1. + 尽量不用，会开辟内存空间，效率低

        2. %s 万能
            -- %.4s  (截取字符串前4位)

        3. %d 整型数字

        4. %f 浮点数（默认小数点后取6位）
            -- %.2f  (小数点后取2位)

        5. %% 百分号



二、format 方法

    # 一般方法
    --  s = 'i am {} , my age is {}' .format('shendaw',22)

    # 元祖索引方式取值
    --  s = 'i am {1} , my age is {0}' .format(22,'shendaw')
    --  s = 'i am {1} , my age is {0}' .format(*(22,'shendaw'))
    --  s = 'i am {1} , my age is {0}' .format(*[22,'shendaw'])

    # 字典方式取值
    --  s = 'i am {name} , my age is {age}' .format(name='shendaw',age=22)
    --  s = 'i am {name} , my age is {age}' .format(**{'name':'shendaw','age':22})

    # 强制转换类型
    --  s = 'i am {:s} , my age is {:d}' .format('shendaw',22)

三、函数

1. 函数与过程：
        过程：没有返回值的函数

2. 啥时候用函数：
        1. 减少重复代码 （有超过两次的重复）
        2. 保持一致性（易维护）
        3. 增强可扩展性
        4. 封装一个功能

3. 出现同名的函数：
        前面的都会被覆盖掉,只有最后一个生效

4. 遇到第一个return即结束

5. def jj (x,y,z=6)
        z的缺省值为6

6. 可变长度参数：

    def jj (x,y,*args)  #可变长度的列表（元祖）
    def jj (x,y,**kwargs) #可变长度的字典

    传参：
    def jj (x,y,z):

    jj( *[1,2,3] ) #遍历取元素

四、刷题 -- 剑指offer

''' 3. 输出任一重复的数字 '''

s = input('please input the figers:')
li = s.split(' ')

print(li)

''' 50. 输出第一个无【重复】的字符 '''

# 1. 用列表自带的count方法----代码最简单
# s = input('please input the string:')
# s = list(s)
# for item in s :
#     if s.count(item) == 1 :
#         print(item)
#         break

# 2. 构造辅助哈希表（字典）----时间复杂度最小
# s = input('please input the string:')
# dic = {}
# # 创建哈希表
# for item in s :
#     dic.update({item:0})
# # 向哈希表填值
# for item in s :
#     dic[item] += 1
# # 以哈希表辅助寻找次数 =1的字符
# for item in s :
#     if dic[item] = 1 :
#         print(item)
#         break

# 3. 创建两个容器，一个放不同的，一个放重复的。
#    s1-s2得无重复的元素集合

# s = input('please input the string:')
#
# s1 = []
# s2 = set()
# for item in s:
#     if item not in s1 :
#         s1.append(item)
#     else :
#         s2.add(item)
# for item in s2:
#     s1.remove(item)
#
# print(s1[0])

五、刷题 -- 字节跳动 -- leetcode

# 3. 无重复字符的最长子串

# v = input('请输入字符串：')
# def find_max_length_from_i(v) :
#     l = []
#     for i in range(len(v)) :
#         v_new = []
#         for j in range(i,len(v)) :
#             if v[j] not in v_new :
#                 v_new.append(v[j])
#             else:
#                 l.append(len(v_new))
#                 break
#             j += 1
#         i+=1
#     r = l.sort()
#     r = l[-1]
#     return r
#
# r = find_max_length_from_i(v)
# print(r)

############## 法二
# v = input('请输入字符串：')
# def hhh(v) :
#
#     t2 = []
#     for i in range(len(v)):
#         t1 = []
#         cnt= 0
#         for j in range(i,len(v)):
#
#             if v[j] not in t1:
#                 t1.append(v[j])
#                 cnt += 1
#             else:
#                 break
#             j += 1
#         t2.append(cnt)
#         i += 1
#     return max(t2)
#
# r = hhh(v)
# print(r)

'''
 10/9
'''
''' 1. 分类 -- 通过 '''
# test = input('please input the string:')
# res = 0
# n = len(test)
# for j in range(n) :
#     temp = []
#     for i in range(j,n) :
#         if i < n-1 :
#             if test[i] not in temp :
#                 temp.append(test[i])
#             else :
#                 len_temp = len(temp)
#                 if len_temp > res :
#                     res = len_temp
#                 break
#         else :
#             if test[i] not in temp :
#                 temp.append(test[i])
#                 len_temp = len(temp)
#                 if len_temp > res :
#                     res = len_temp
#             else:
#                 len_temp = len(temp)
#                 if len_temp > res :
#                     res = len_temp
# print(res)
''' 2. flag -- 未通过 '''
# test = input('please input the string:')
# res = 0
# n = len(test)
# for j in range(n) :
#     temp = []
#     flag = 0
#     for i in range(j,n) :
#         if i == n-1 or test[i] in temp :
#             flag = 1
#         if test[i] not in temp :
#             temp.append(test[i])
#         if flag == 1 :
#             len_temp = len(temp)
#             if len_temp > res:
#                 res = len_temp
#             break
# print(res)

''' 3. 实时更新 -- 未通过 '''
# test = input('please input the string:')
# res = []
# for j in range(len(test)) :
#     temp = []
#     for i in range(j,len(test)) :
#         if test[i] not in temp :
#             temp.append(test[i])
#             print('temp:',temp)
#             print('res:',res)
#             if len(temp) > len(res) :
#                 res = temp
#                 print('更新！')
#         else :
#             break

六、刷题 -- 字节跳动 -- 牛客网

   ''' 
        血的教训：面试题
        # 题目：将数组nums中所有0放到结尾去
        # 错因：删除导致循环溢出、下标漏掉元素
        # 经验：删除、循环溢出、下标漏元素 ———— 创建新容器
   '''

# nums = [1,0,2,4,6,0,0,3]
# res = []
# cnt = 0
# for i in range(len(nums)) :
#     if nums[i] != 0 :
#         res.append(nums[i])
#     else :
#         cnt += 1
# for i in range(cnt) :
#     res.append(0)
#
# print(res)


'''
1、万万没想到之聪明的编辑
'''
####### 1. 删除法 - 失败 ######

# test1 = input('请输入字符串：')
# test1 = list(test1)
# for i in range(len(test1)-2):
#     if test1[i] == test1[i+1]:
#         if i+2<len(test1)-1 and test1[i+2] == test1[i+1]:
#             test1.pop(i+2)
#         elif i+3<len(test1)-1 and test1[i+2] == test1[i+3]:
#             test1.pop(i+2)
# print(test1)

####### 2. 添加法 -成功 ######

# 分次输入 — 简单
# n = int(input())
# while n:
#     test1 = input()
#     test1_new = []
#     for i in range(len(test1)):
#         if i>=2 and test1[i-2] == test1[i-1]:
#             if test1[i] == test1[i-1]:
#                 continue
#             elif i<len(test1)-1 and test1[i] == test1[i+1]:
#                 continue
#             else :
#                 test1_new.append(test1[i])
#         else:
#             test1_new.append(test1[i])
#
#     print(''.join(test1_new))
#     n-=1


# 连续输入 - 较麻烦
# n = int(input('请输入n:'))
# n1 = n
# test = []
# while n:
#     test.append(list(input('请输入字符串:')))
#     n-=1
#
# for j in range(n1):
#     test_new = []
#     for i in range(len(test[j])):
#         if i>=2 and test[j][i-2] == test[j][i-1]:
#             if test[j][i] == test[j][i-1]:
#                 continue
#             elif i<len(test[j])-1 and test[j][i] == test[j][i+1]:
#                 continue
#             else :
#                 test_new.append(test[j][i])
#         else:
#             test_new.append(test[j][i])
#
#     print(''.join(test_new))
#     n-=1


########### 大佬解法 ########

# n = int(input())
# while n > 0:
#     s = input()
#     res = []
#     for e in s:
#         if len(res) < 2:
#             res.append(e)
#             continue
#         if len(res) >= 2:
#             if e == res[-1] and e == res[-2]:
#                 continue
#         if len(res) >= 3:
#             if e == res[-1] and res[-2] == res[-3]:
#                 continue
#         res.append(e)
#     print("".join(res))
#     n -= 1


# 2. 万万没想到之抓捕孔连顺
# 初步可行：
# s = input()
# n,d = s.split(' ')
# n = int(n)
# d = int(d)
# b = input().split(' ')
# cnt = 0
# for i in range(n-2):
#     for j in range(i+1,n-1):
#         for k in range(j+1,n):
#             if int(b[k]) - int(b[i]) <= d :
#                 cnt+=1
# print(cnt)

# s = input()
# n,d = s.split(' ')
# n = int(n)
# d = int(d)
# b = input().split(' ')
# cnt = 0
# for i in range(n-2):
#     for j in range(i+1,n-1):
#         if int(b[j]) - int(b[i]) <= d :
#             for k in range(j+1,n):
#                 if int(b[k]) - int(b[i]) <= d :
#                     cnt+=1
# print(cnt % 99997867)


# 自由落体

# import time
#
# time_start=time.time()
# while True:
#     t = time.time() - time_start
#     y = 0.5*9.8*t**2
#     print('(0,%s)' %y)