閱讀目錄：

  1.變數

   2.用戶與程式交互

   3.基本數據類型

   4.格式化輸出

   5.基本運算符

   6.流程式控制制之if....else

   7.流程式控制制之while迴圈

   8.流程式控制制之for迴圈

   9.開發工具IDE

   10.擴展閱讀

   11：作業

1.變數                                                                                   

#編碼
中文編碼有萬國碼（Unicode）、utf8、GBK
其中utf8中文占三個位元組，GBK中文占兩個位元組，一個位元組等於八位
其中utf8可以跟Unicode相互轉化
GBK可以轉變成unicode Unicode做中文處理的時候可以與GBK轉化

1.變數必須由字母數字下劃線組成
2.數字不能作為開頭
3.不能是python中的關鍵字，最好不要跟python中內置的東西重覆

定義變數會有 id type value

註意：1.=比較的是vlaue
     2.is 比較的是id



強調：1.id相同，意味著type跟value必定相同
     2.value相同type不也相同，id可能不相同：
          x='juxianwen'
          y='juxianwen'
          id(x)
          4376607152
          id(y)
          4376607408
          x==y
          True
          x is y
          False

#1.在交互模式下
python實現int的時候由小數池。為了避免因為創建相同的值而重覆申請記憶體空間所帶來的效率問題，python解釋器會再啟動時創建出小數池，
範圍是[-5,256]，在該範圍內的整數對象是全局解釋器範圍內被重覆使用，永遠不會被回收。（也就是說創建出來這個範圍內相同的數字的id
相同）


#在pycharm中
在pycharm中會過大這個範圍

常量

常量是指不變的量，程式員約定俗成的用變數名全大寫表示常量

#ps 在c語言中有專門的常量定義語法，const、int、count，一旦定義為常量，更改便會報錯

2.用戶與程式交互                                                                                                                                                                                                                                                 

#在python3中
input：用戶輸入的任何值，都存成字元串類型



#在python2中
input：用戶輸入什麼類型，就存什麼類型
raw_input:等於python3的input

完成一個用戶程式交互：1.提醒用戶輸入用戶名跟密碼

                                        2.獲取用戶名跟密碼，如果用戶名是：root  密碼是：root 提示正確登錄，否則登錄失敗

1 name=input('請輸入用戶名：')
2 pass_world=input('請輸入用戶密碼：')
3 if name=='root' and pass_world=='root':
4     print('登錄成功')
5 else:
6     print('登錄失敗')

代碼註釋原則：

#1  不用全部都加註釋，只是把自己覺得難理解的地方加上註釋
 2. 註釋可以用中文也可以用英文但是不要用拼音
 3.單行註釋用# 多行註釋用三對雙引號"""  """

 三  基本數據類型                                                                                                                                                                                                                                          

數字

#int 整型
定義：age=10  #age=int(10)
功能：用於標識 工資 身高 體重

#int整形瞭解部分
在32位機器上，整型的位數為32位，取值範圍為 -2**32~2**32-1
在64位系統上，整型的位數為64位，取值範圍為-2**63~2**63-1



#long長整型
跟c語言不同，python的長整型沒有指定位寬，即：python沒有限制長整型的數值大小，但由於機器記憶體有限制所有我們使用的長整型不能
無限大。

註意在python2.2以後，如果整型發生溢出，那麼python自動將整數數據轉化為長整數，所以現在長整數數據後面不加字母L也不會產生嚴重
後果。


註意自python3以後不再有長整型，全部是int

整型的功能
1.如何將其他形式轉化為整型：
  若a='123'
  b=int(a) 這樣子b=123 b就變成了一個整型

  num='0011'

   Int（num，base=2）base=2是指以二進位的形式輸出0011，base=16，是以16進位的形式進行輸出，所以這個程式就是將0011以二進位的 形式進行轉化為十進位，所以輸出以後為3.

2.__.bit_length()的功能

  這個的功能是這個數字用二進位表示至少需要幾位

例如：age=10

      R=age.bit_length()

      Print(R)

字元串

#在python中，加了引號的字元就是字元串類型，python並沒有字元類型。
定義：name='jxw' 相當於name=str(jxw)
用於標識：描述性內容，如姓名、性別等
len,join,for,索引切片 在別的數據結構中也能用

#那麼單引號、雙引號、多引號有什麼區別呢？
單雙引號沒有什麼區別，只有在下麵這種情況你需要考慮單雙號的配合。
msg=" I'am A"


多引號用於進行多行註釋。

#字元串的加減
name='jxw'
age='18'
name+age  輸出的是  jxw18 類型是字元串
name*5    輸出的是 jxwjxwjxwjxwjxw 類型是字元串

註意1：字元串相加的效率不高
字元串1+字元串2，並不會在字元串1的基礎上加上字元串2，而是申請一個全新的記憶體空間，存放字元串1和字元串2，所以占用了記憶體。
註意2：只能字元串加字元串，不能字元串加其他類型

#字元串的功能
1.字元串首字母大寫
  text='alex'
  v=test.capitalize()
  print(v)  輸出的是Alex
2.大寫變成小寫
  test.casefold() 這條命令是不管什麼國家的語言都可以變成小寫
  test.lower() 這個是只能英文字元大寫轉化為小寫
3.填補功能
  test='alex'
  v=test.ceter(20)
  print(v)
  輸出的是        alex       空格加alex總共為20位
  v=test.cete(20,'*')
  print(v)
  輸出的是********alex********
4.計算字元串中某個字元的個數
  test='alexalex'
  v=test.count('e')
  計算e在alexalex中出現多少次
  v=test.count('ex',1,6)從第二個位置到第七個位置ex出現了多少次，但是不包括第二個位置跟第七個位置
5.判斷以什麼結尾，以什麼開頭
 test='alex'
 test.endwith('a',1,3)  看alex 在它的第二個位置到第四個位置是不是以a結尾的（包括第四個位置）
 test.startwith('a') 看alex是否以a開頭
6.尋找目標所在位：
 test='alexalex'
 v=test.find('ex',1,4) 在第二個位置跟第五個位置尋找ex在哪個位置（不包括第五個位置），尋找到第一個ex就不往後找了
7.將字元串中的占位符替換成指定的值
test='I am {name},age{a}'
test.format(name='alex',a=19) 輸出I am alex，age19

相當於test='I am {name},age{name}'.format(**{name:'alex',age:19})字典形式得加**

test='I am {0},age{1}'test.format('alex',19)   輸出I am alex，age19  按照順序來的先0後1

test='I am {name}'.format('name'='xa')
test.format_map({'name':'alex'})輸出的是 I am alex 
test='{0},{0}'.format(1,2,3)輸出的是11
test='i am {0[1]}'.format([1,2,3],[123])輸出的[1,2,3]中的第二個元素 即 i am 2
test='{:s} {:d} {:f}'.format('sex',1,1.2) :s接受字元串 :d接受數字 :f接受浮點數 輸出的是 sex 1 1.2
test='{:s} {:d}'.format(*['sex',12])  *['sex',12]是指的是輸入整個列表 輸出的是 sex 12

test='{:b}(輸入二進位) {:o}(輸入八進位) {:d}(輸入整型) {:x}（16進位 輸入小寫abcd） {：X}（輸入16進位 輸入大寫ABCD）
      {.%}(顯示百分比預設顯示小數點6位)'.format(15,1,15,15,15,15,8,2)
      


8.尋找位元組在哪個位置

Text=’alexalex’

V=text.index(‘a’,4,5)

尋找a在哪個位置，如果沒有4，5則預設從第零位開始，否則從第四位查找（包括第四位）到第五位結束（不包括第五位），

遇到一個a直接輸出a的位置，這個a以後的則不查找，也就是說查找第一個a所在的位置。

9.判斷字元串是否只包含字母與數字
test.isalnum 是的話是True不是的話Flase
10.斷句換行功能
expandtabs（a）在a個字元之內遇到\t直接用空格填充到6
比如：s='uba\tk'
     a=s.expandtabs(6)輸出的是uba  k總共位
斷句，先將前6個拿出來無tab忽略再找6個，找到\t後補充到6個
11.判斷是否全為字母跟漢字
text.isalpha（） 全是輸出True 反之輸出Flase
12.判斷是否全為數字
test.isdecimal() 這個甚至可以判斷特殊的數字比如① 二
test.isdigit()只能判斷普通的數字
12.判斷是否為標識符 
標識符=有字母數字下劃線組成（字母不開頭）
test.isidentifier()是的話TRUE反之Flase
13.islower（）判斷是否為小寫
14.判斷是否可以列印
什麼叫做可列印：如果存在\t,\n這些不可現實的字元就是不可列印
test.isprintable() 可列印true反之false
15.判斷是否全為空格
test.isspace（）判斷是否全為空格
16.判斷是否為標題
什麼是標題：所有單詞的首字母大寫就是標題
test.istitle()
17.將字元串中的每個元素按照指定分隔符進行拼接
join(self,iterable)
test='你是風兒，我是沙'
t=' '
v=t.join(test) 輸出 你 是 風 兒 ， 我 是 沙
18.填充字元

右填充 ljust
v='alex'
a=v.ljust(5,'*') 輸出的是*alex
左填充
v='alex'
a=v.rjust(5,'*')輸出的是alex*
左填充0（只能填充0）
v='alex'
a=v.zfill(5)輸出的是0alex
19.判斷字元串是否全為大寫
test.isupper()
20.消除指定字元串
消除空格
test.strip()消除兩邊空格
test.lstrip()消除左邊空格
test.rstrip()消除右邊空格
\n \t 也可以消除 
test='\nalex'
v=test.lstrip()這樣輸出的也是alex
消除指定的元素
test='xalex'
v=text.lstrip('x')  輸出的是alex
21.轉變字元串的特定內容
test='你是風兒我是沙'
text1='去你媽的風和沙'
v='你是風兒我是沙，纏纏綿綿去你家'
將v中test內容換成test1中的內容
m=v.maketrans('你是風兒我是沙'，'去你媽的風和沙')
new_v=tanslate（m）
22.分割
test='testastsd'
test.partition('s') 輸出的是 'te','s','tastsd' 只分割第一個s
test.rpartition('s')從右起第一個s作為分割 'testast','s','d'
test.split('s') 'te','ta','t','d'
可以指定分割次數test.split('s',1)輸出的是'te','tastsd'
從右開始分割 test.rsplit('s')
22.根據換行符進行分割
test='a\na\n'
v=test.splitlines()輸出的['a','a']
v=test.splitlines(True)輸出的是['a\n','a\n']
v=test.splitline(Flase)輸出的是['a','a']
23.大小寫轉換
test='alex'
v=test.swapcase() 輸出的是ALEX 
24.字元串的索引，切片，長度功能
test='alex'
索引 test[0] 輸出的是a
切片 test[0:1] 輸出範圍 0=<x<1 
    test[0:-1]輸出的範圍是第一位到最後一位
長度 test='你是豬'
    len(test)在python3中輸出的是三，在python2中輸出的是9 因為utf8中一個漢字占三位
    li=['2','1','0']
    len(li)輸出的是三
for zjw in test:
    print(zjw)
相當於：
index=0
while index <len(test):
    v=test[index]
    print(v)
    index=index+1
25.替換
test='alexalexalex'
test.replace('ex','bbb')輸出的是albbbalexalex
test.replace('ex','bbb',2)輸出的是albbbalbbbalex
26.創建連續的數字
v=range(100)
print(v) 輸出的是range(100)
for i in v:
     print(i) 輸出的是0到99
也可以設置步長
v=range(0,100,5)
for i in v:
    print(i)輸出的是0 5 10 。。。。

#習題 將 文件索引列印出來
test=input('')#需要列印索引的內容
l=len(test)
r=range(0,l)
for k in r:
    print(k,test[k])

 列表

#在[]內用逗號分隔，可以存放n個任意類型的值 
定義：students=['1','2','3']
#students=list(['1','2','3'])
用於標識：存儲多個值得情況，比如一個人的多個愛好

#存放多個學生的信息：姓名，年齡，愛好
student_info=[['egon',18,['play']],['alex',18,['play','sleep']]]
student_info[0][2],[0] 輸出的是play
列表可以有索引、切片
列表可以進行for，while 自然也支持break contiune

鏈表：因為列表存儲不是連續存的，就是在第一個位置里存放著第二個位置的坐標。正因為列表存儲不連續，所以列表可以修改
     比如：列表第一個位置為20
          li[0]=120 第一個位置就由20變成120

1.刪除，修改功能
del li[1] 將li的第二個位置刪除掉
del li[2:6]刪除li的 3,4,5,6位置的元素
li[1:3]=[120,90]第二位換成120，第三位換成90
2.列表中是否有這個元素
v=12 in li
print(v)如果12在li中輸出的True 如果不在輸出Flase
3.取列表的特定的值
li=[1,12,9,8,['1',['19',10]],'alex',True]
li[4][1][0] 輸出的是19
4.字元串轉化為列表的原理
s='1234'
list(s)
這個原理是
list=[]
for i in s:
    list=list.append(i)
li=[1,2,3]
str(li）輸出的是'[1,2,3]'
5.末端插入
li=[1,2,3]
li.append(5)
print(li)輸出的是[1,2,3,5]
5.清空列表
li.clear()
6.淺拷貝
li.copy
7.計算列表中元素出現了多少次
v=li.count(22)看列表li中22出現了多少次
8.擴展列表，參數為可迭代對象
li=[11,22,33,44,55]
li=extend([98,12])
print(li)  輸出的是[11,22,33,44,55,98,12]
9.從左往右找值，找到第一個就不繼續找下去了
li=[11,22,33,44,55]
v=li.index(22) #index(x,start,end)
10.在指定位置插入一個值
li=[11,22,33]
li.insert(0,99)
print(li)輸出的是[99,11,22,33]
11.刪除指定位置元素，並且可以獲取到這個元素
li=[1,2,3]
v=li.pop()
print(v)輸出的是3
v=li.pop(1)刪除第二個位置的元素,並獲取這個值賦值給v
12.刪除指定元素
li.remove(22)刪除從左到右第一個22
13.將列表進行翻轉
li=[1,2,3]
li.reverse()
print(li)輸出的是[3,2,1]
14.進行排列
li=[11,44,22,33,22]
li.sort
print(li) 輸出的是[11,22,22,33,44]
li.sort(reverse=True)
print(li)輸出的是[44,33,22,22,11]

#練習題
1.l=[1,2,3,4,5,6]
  正向步長：l[0:3:1] 輸出的是[1,2,3]
  反向步長：l[2：：-1]輸出的是[3,2,1]
  列表翻轉：l[::-1]輸出的是[6,5,4,3,2,1]
2.用列表data=['alex',49,[1900,3,18]],分別取出列表中名字，年齡，出生的年，月，日賦值給不同的變數
  data[0]輸出的是 alex
  data[1]輸出的是 49
  data[2]輸出的是 [1900,3,18]

元組

列表：有序、[]、可以增刪
元組：li=（1,2）小括弧，可以查看li[0]（這裡就已經證明元組是有序的）,li[0:6]，但是不可以修改跟刪除,可迭代 for i in li： 
因為可以迭代所以 元組列表
     字元串可以相互轉化。註意：元組的一級元素不可修改、刪除、增加，但是二級元素確不一定不可以修改。
元組的join可以用
tu=（'asdf','asdf'）
v='_'join(tu)輸出的是asdf_asdf
count計數
index獲取指定元素在元組中的索引

 字典

字典的作用：可以存放多個任意類型的值，並且可以硬性規定值得映射關係。

#在{}內用逗號分隔，可以存放多個key，value的值，其中value可以是任意值，key只能是數字、字元串、布爾值，每一個值都有唯一一個
key對應，可以更為高效方便的取值。
註意：key重覆時只能保留一個
     布爾值作為key時，True相當1，所以數字1跟True同時存在的時候只保留一個。False相當於數字0.

info={
     'name':'se',
     'hobbies':['play','sleep'],
     'company_info':{
          'name':'oldboy',
          'type':'edu'
          'emp_num':40
     }
  
}
print(info['company_info']['name']} 輸出的是 oldboy
del infor('name') name:se 這個鍵值對就被刪除了

註意：字典不可以被while迴圈，但是可以進行for迴圈。
for i in infor:  相當於 for i in infor.keys(): 預設輸出的是key
for i in infor.values():  這個是只迴圈初values
for i,v in infor.items(): 這個是將key value 都迴圈出來。
v='v1' in dic.values() 判斷v1在沒在value中出現

字典的功能：

1.clear清空功能

2.copy複製功能

3.fromkeys（直接寫類名）根據序列創建字典，並指定統一值。

v=dict.fromkeys(['k1',123,'99'])
print（v)輸出的是{123:None,'k1':None,'999':None}
4.字典的取值功能


v=dic.get('k1')取到k1這個鍵對應的值，如果沒有輸出None



v=dic.get('k11',111)輸出k11鍵對應的那個值，如果沒有輸出111

5.字典的刪除功能
v=dic.pop('k1')刪除k1對應的那對鍵值對
print(k1)輸出k1那個鍵對應的那個值

v=dic.pop('k1',111)
print(v)如果字典中本來沒有k1 這樣就輸出111
6.設置預設值
v=dic.setdefault('k1','123')如果k1存在則k1不設置成123，print(k1)將輸出字典中的k1
如果k1不存在，那麼將k1作為鍵123作為值放入字典中，print（dic['k1']）輸出的是123
7.更新
dic.update({'k1':'1111','k2'=123}) 相當於 dic.(k1='1111',k2=123)
如果dic中k1已經存在，那麼久覆蓋掉，如果不存在更新上。

 布爾值

#布爾值 一個True 一個False
bool（a）將a轉化為布爾值
#所有類型都自帶布爾值
1.None，0，空 都為False
2.其餘值都為True

重點

#可變類型：在id不變的情況下，value可變，則稱為可變類型，如列表、字典。
#不可變類型：value一旦改變，id也得變，則成為不可變類型（id變，意味著創立新的記憶體空間）

集合

#作用：去重、關係運算
#集合的定義：
   1.集合可以包括多個元素，用逗號分割開
   2.每個元素必須是不可變類型（可hash，可作為字典key）
   3.沒有重覆元素
   4.無序
例：s=set('hello')
   print(s)輸出的是{'h','e','l','o'}
   
   s=set(['alex','alex','sb'])
   print(s)輸出的是{'alex','sb'}

#集合的功能
1.添加元素
s={1,2,3}
s.add('s')
print(s)輸出的是{1,2,3，s}
2.清空功能
s.clear()
print(s) 輸出的是set（）
3.複製功能
s1=s.copy()
這個我相當於s1==s
4.刪除功能
v=s.pop()這個是隨機刪除
v=s.remove(1)指定刪除元素1，如果沒有1，則會報錯
v=s.discard（1）指定刪除元素1，如果沒有1也不會報錯
5.交集
python_1=['lv','gh','gg']
linux_1=['lv','cnm','nmb']
python_and_linux=[]
for i in python_1:
    if i in linux_1:
        python_and_linux.append(i)
python_and_linux=set(python_and_linux)    
這段程式相當於 p_s=set(python_1)
            l_s=set(linus_1)
            print(p_s.intersection(l_s)) 相當於 print(p_s&l_s)
6.並集
print(p_s.union(l_s)) 相當於 print(p_s|l_s)
7.差集：p_s中減去P_s與l_s的交集
print(p_s.different(l_s))相當於print(p_s-l_s)
進行差集以後，p_s與l_s並沒有改變
p_s=p_s-l_s 相當於 p_s.different.updata(l_S)  p_s就更新為 p_s-l_s
8.交叉補集：p_s並上l_s在減去p_s交上l_s
print(p_s.symmetric_difference(l_s)) 相當於 print(p_s^l_s)
9.判斷s1，s2集合是否為空
print(s1.isdisjoint(s2))若是為空則輸出True
10.子集，復集   若s1為s2的子集，那麼s2為s1的復集
子集：print(s1.issubset(s2))如果是子集輸出True
復集 ：print(s2.issuperset(s1))如果 s2>=s1那麼輸出True
11.不可變集合：
s=forzenset('hello')
通過這個命令形成的集合不可增加也不可刪除

有如下列表
l=[
{'name':'alex','age' :18,'sex'='male'}

{'name':'egon','age' :73,'sex'='male'}

{'name':'alex','age' :20,'sex'='female'}

{'name':'alex','age' :18,'sex'='male'}

{'name':'alex','age' :18,'sex'='male'}

],去重，得到新列表並且保留原來順序。

a=[{'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'alex', 'age': 73, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'female'},

    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},

   ]
b=[]


num=len(a)



while num>0:

    num=num-1
    v=a.pop()


    for i in a:
        if i['name']==v['name'] and i['age']==v['age'] and i['sex']==v['sex']:
            a.remove(i)#當a發生改變時直接跳出for 迴圈
    a.append(v)

print(a)

 數據類型總結                                                                                                                                                                                                                                                

按存儲空間的占用分（從低到高）

數字
字元串
集合：無序，即無序存索引相關信息
元組：有序，需要存索引相關信息，不可變
列表：有序，需要存索引相關信息，可變，需要處理數據的增刪改
字典：無序，需要存key與value映射的相關信息，可變，需要處理數據的增刪改

四 格式化輸出                                                                                                                                                                                     

程式中經常會有這樣場景：要求用戶輸入信息，然後列印成固定的格式

    比如要求用戶輸入用戶名和年齡，然後列印如下格式：

    My name is xxx，my age is xxx.

    很明顯，用逗號進行字元串拼接，只能把用戶輸入的名字和年齡放到末尾，無法放到指定的xxx位置，而且數字也必須經過str(數字)的轉換才能與字元串進行拼接。

    這就用到了占位符，如：%s、%d

#%s字元串占位符：可以接收字元串，也可接收數字
print('My name is %s,my age is %s' %('egon',18))
#%d數字占位符：只能接收數字
print('My name is %s,my age is %d' %('egon',18))
print('My name is %s,my age is %d' %('egon','18')) #報錯

#接收用戶輸入，列印成指定格式
name=input('your name: ')
age=input('your age: ') #用戶輸入18,會存成字元串18,無法傳給%d

print('My name is %s,my age is %s' %(name,age))

#註意：
#print('My name is %s,my age is %d' %(name,age)) #age為字元串類型,無法傳給%d,所以會報錯

浮點數（小數）的格式化：

tp1='percent %f'%99.975   這個%f 預設保留6位 所以輸出的是percent99.975000

tp1='percent%..2f'%99.9765 這個保留兩位小數 輸出的是 percent99.97

tp1='percent%..2f%%'%99.222 這個%%是指輸出% 輸出的是percent99.22%

字典的形式格式化：

tp1='i am %(name)s age %(age)d '%{'name':'alex','age':19}輸出的是 i am alex age 19

print中的sep分割：

print（'root','x','0','0',sep=':'）這個值得是以：分割 輸出的是 root：x：0:0:

 五 基本運算符                                                                                                                                                                                     

 電腦可以進行的運算有很多種，可不只加減乘除這麼簡單，運算按種類可分為算數運算、比較運算、邏輯運算、賦值運算、成員運算、身份運算、位運算，今天我們暫只學習算數運算、比較運算、邏輯運算、賦值運算

算數運算

    以下假設變數：a=10，b=20

比較運算

    以下假設變數：a=10，b=20

賦值運算

    以下假設變數：a=10，b=20

 邏輯運算

#三者的優先順序從高到低分別是：not，or，and
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False
#最好使用括弧來區別優先順序，其實意義與上面的一樣
>>> (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)
False 

 身份運算

#is比較的是id
#而==比較的是值

 六控制流程之 if....else語句                                                                                                                                                                    

既然我們編程的目的是為了控制電腦能夠像人腦一樣工作，那麼人腦能做什麼，就需要程式中有相應的機制去模擬。人腦無非是數學運算和邏輯運算，對於數學運算在上一節我們已經說過了。對於邏輯運算，即人根據外部條件的變化而做出不同的反映，比如

# 如果:今天是Monday,那麼:上班
# 如果:今天是Tuesday,那麼:上班
# 如果:今天是Wednesday,那麼:上班
# 如果:今天是Thursday,那麼:上班
# 如果:今天是Friday,那麼:上班
# 如果:今天是Saturday,那麼:出去浪
# 如果:今天是Sunday,那麼:出去浪


#方式一：
today=input('>>: ')
if today == 'Monday':
    print('上班')
elif today == 'Tuesday':
    print('上班')
elif today == 'Wednesday':
    print('上班')
elif today == 'Thursday':
    print('上班')
elif today == 'Friday':
    print('上班')
elif today == 'Saturday':
    print('出去浪')
elif today == 'Sunday':
    print('出去浪')
else:
    print('''必須輸入其中一種:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

#方式二：
today=input('>>: ')
if today == 'Saturday' or today == 'Sunday':
    print('出去浪')

elif today == 'Monday' or today == 'Tuesday' or today == 'Wednesday' \
    or today == 'Thursday' or today == 'Friday':
    print('上班')

else:
    print('''必須輸入其中一種:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')


#方式三：
today=input('>>: ')
if today in ['Saturday','Sunday']:
    print('出去浪')
elif today in ['Monday','Tuesday','Wednesday','Thursday','Friday']:
    print('上班')
else:
    print('''必須輸入其中一種:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

七 流程式控制制之while迴圈                                                                                                                                                                     

條件迴圈：while，語法如下 

while 條件:    
    # 迴圈體
 
    # 如果條件為真，那麼迴圈體則執行，執行完畢後再次迴圈，重新判斷條件。。。
    # 如果條件為假，那麼迴圈體不執行,迴圈終止

#列印0-10
count=0
while count <= 10:
    print('loop',count)
    count+=1

#列印0-10之間的偶數
count=0
while count <= 10:
    if count%2 == 0:
        print('loop',count)
    count+=1

#列印0-10之間的奇數
count=0
while count <= 10:
    if count%2 == 1:
        print('loop',count)
    count+=1

死迴圈

import time
num=0
while True:
    print('count',num)
    time.sleep(1)
    num+=1　　 

迴圈嵌套與tag

　tag=True 

　　while tag:

　　　　......

　　　　while tag:

　　　　　　........

　　　　　　while tag:

　　　　　　　　tag=False

#練習，要求如下：
    1 迴圈驗證用戶輸入的用戶名與密碼
    2 認證通過後，運行用戶重覆執行命令
    3 當用戶輸入命令為quit時，則退出整個程式 

#實現一：
name='egon'
password='123'

while True:
    inp_name=input('用戶名: ')
    inp_pwd=input('密碼: ')
    if inp_name == name and inp_pwd == password:
        while True:
            cmd=input('>>: ')
            if not cmd:continue
            if cmd == 'quit':
                break
            print('run <%s>' %cmd)
    else:
        print('用戶名或密碼錯誤')
        continue
    break

#實現二：使用tag
name='egon'
password='123'

tag=True
while tag:
    inp_name=input('用戶名: ')
    inp_pwd=input('密碼: ')
    if inp_name == name and inp_pwd == password:
        while tag:
            cmd=input('>>: ')
            if not cmd:continue
            if cmd == 'quit':
                tag=False
                continue
            print('run <%s>' %cmd)
    else:
        print('用戶名或密碼錯誤')

 continue  break

break 是直接結束所有迴圈 continue結束當前迴圈在會到本層迴圈重新開始迴圈
while 1==1：（break直接回到這裡並且結束這裡）

     while 1==1：(while 是結束迴圈回到這裡並且繼續執行迴圈)

         a=input（'請輸入'）

         if  a=='a':

              contiune

         else:

              break

 while+else

#與其它語言else 一般只與if 搭配不同，在Python 中還有個while ...else 語句，while 後面的else 作用是指，當while 
迴圈正常執行完，中間沒有被break 中止的話，就會執行else後面的語句
count = 0
while count <= 5 :
    count += 1
    print("Loop",count)

else:
    print("迴圈正常執行完啦")
print("-----out of while loop ------")
輸出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
迴圈正常執行完啦
-----out of while loop ------

#如果執行過程中被break啦，就不會執行else的語句啦
count = 0
while count <= 5 :
    count += 1
    if count == 3:break
    print("Loop",count)

else:
    print("迴圈正常執行完啦")
print("-----out of while loop ------")
輸出

Loop 1
Loop 2
-----out of while loop ------

 while迴圈練習題

#1. 使用while迴圈輸出1 2 3 4 5 6 8 9 10
#2. 求1-100的所有數的和
#3. 輸出 1-100 內的所有奇數
#4. 輸出 1-100 內的所有偶數
#5. 求1-2+3-4+5 ... 99的所有數的和
#6. 用戶登陸（三次機會重試）
#7：猜年齡游戲
要求：
允許用戶最多嘗試3次，3次都沒猜對的話，就直接退出，如果猜對了，列印恭喜信息並退出
#8：猜年齡游戲升級版
要求：
允許用戶最多嘗試3次
每嘗試3次後，如果還沒猜對，就問用戶是否還想繼續玩，如果回答Y或y, 就繼續讓其猜3次，以此往複，如果回答N或n，就退出程式
如何猜對了，就直接退出

#題一
count=1
while count <= 10:
if count == 7:
count+=1
continue
print(count)
count+=1

count=1
while count <= 10:
if count != 7:
print(count)
count+=1

#題目二
res=0
count=1
while count <= 100:
res+=count
count+=1
print(res)

#題目三
count=1
while count <= 100:
if count%2 != 0:
print(count)
count+=1

#題目四
count=1
while count <= 100:
if count%2 == 0:
print(count)
count+=1



#題目五
res=0
count=1
while count <= 5:
if count%2 == 0:
res-=count
else:
res+=count
count+=1
print(res)

#題目六
count=0
while count < 3:
name=input('請輸入用戶名：')
password=input('請輸入密碼：')
if name == 'egon' and password == '123':
print('login success')
break
else:
print('用戶名或者密碼錯誤')
count+=1

#題目七
age_of_oldboy=73

count=0
while count < 3:
guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1

#題目八
age_of_oldboy=73

count=0
while True:
if count == 3:
choice=input('繼續(Y/N?)>>: ')
if choice == 'Y' or choice == 'y':
count=0
else:
break

guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1

 for迴圈                                                                                                                                                                                               

for i in range（1,9）：