1.while循環(huán)

while -- 關鍵字 (死循環(huán))

基本結(jié)構

          
            if 條件:
    結(jié)果
    
while 條件：
    循環(huán)體
          
        

          
            while True: #真 執(zhí)行
    print("A")
    print("B")
    print("C")
    print("D")
    print("E")
    print("F")
    print("G")

while False: # 假 不執(zhí)行
    print("A")
    print("B")
    print("C")
    print("D")
    print("E")
    print("F")
    print("G")

print(1)
while False: # 假 執(zhí)行不到
    print("A")
    print("B")
    print("C")
    print("D")
    print("E")
    print("F")
    print("G")
print(2)
          
        

          
            B = True
while B:
    print(1)
print(2)

print(bool(0))
數(shù)字中非零的的都是True

B = 1
while B <= 9:
    print(B)
    B = B+1
          
        

          
            倒序
B = 6
while B >= -5:
    print(B)
    B = B-1

順序
B = -6
while B <= 5:
    print(B)
    B = B+1


正序25-57
B = 25
while B <= 57:
    print(B)
    B = B+1

倒敘57-25
B = 57
while B >= 25:
    print(B)
    B = B-1
          
        

break continue

          
            while True:
    print(A)
    print(B)
    break #終止當前循環(huán) birak下方的代碼不執(zhí)行
    print(C)
print(D)

while True:
    print(A)
    print(B)
    continue #偽裝成臨時當作循環(huán)體中的最后一行代碼(跳出當前循環(huán)繼續(xù)下一個循環(huán))
             #下面代碼不會執(zhí)行
    print(C)
print(D)
          
        

while else

          
            while True:
    print(E)
else:
    print(F)

while True:
    print(A)
    break
print(B)
          
        

總結(jié)

          
                打斷循環(huán)的方式：
        1.自己修改條件
        2.break
    break ——打破當前循環(huán)（終止當前循環(huán)）
    continue ——跳出當前循環(huán)繼續(xù)下次循環(huán)（偽裝成臨時當作循環(huán)體中的最后一行代碼）
    break和continue相同之處：他們一下的代碼都不執(zhí)行
          
        

練習

代碼：25——57——25

          
            def func(x):
    print(x)
    if x < 57:
        x += 1
        func(x)
        print(x - 1)
func(25)
          
        

代碼：循環(huán)

          
            msg = int(input("輸入序號選擇格式(0/1):"))
if msg == 0:
    print("用戶退出成功！")
if msg == 1:
    flag = True
    while flag:
        user = input("請輸入用戶名：")
        pwd = input("請輸入密碼：")
        if user == "大黑哥" and pwd == "123456":
            print("輸入正確")
            flag = False
        else:
            print("請重新輸入！")
          
        

2.字符串格式化

內(nèi)容

          
            A = input("請輸入你的年齡：")
B = "你已活的時長為:%s%%"
print(B%(A))
          
        

          
            a = "------------- info -------------"
b = "name:"
c = "age:"
d = "job:"
e = "-------------- end -------------"
name = input("name")
age = input("age")
job = input("job")
print(a + "\n" + b + name + "\n" + c + age + "\n"+ d + job + "\n" +e)


s = """ ------------- info -------------
name:%s
age:%s
job:%s
-------------- end -------------
"""
name = input("name")
age = int(input("age"))
job = input("job")
print(s%(name,age,job))
          
        

          
            num = input('學習進度：')
s11 = "大哥黑的學習進度為:%s %%"
print(s11%(num))

s = f"今天下雨了{input('>>>')}"
print(s)

s11 = "大哥黑的學習進度為:%s"
print(s11%("不錯"))

s = f"{1}{2}{3}"
print(s)
          
        

總結(jié)

          
            %s 是占的字符串類型的位置
%d 是占的數(shù)字類型的位置
%% 轉(zhuǎn)換成普通的%號
按照位置順序傳遞,占位和補位必須要一一對應
          
        

3.運算符

運算順序

          
            () > not > and > or
從左向右執(zhí)行
          
        

算數(shù)運算符

          
            +
-
*
/ python2獲取的值是整數(shù)，python3獲取的是浮點數(shù)（小數(shù)2.5）
print(5/2)
//(整除-- 地板除)
print(5 // 2)
** 冪（次方）
print(3**2)
% 模 (取余)
print(5 % 2)
          
        

比較運算符

          
            >
<
== (等于)
!= (不等于)
>=
<=
          
        

賦值運算符

          
            = 賦值
+= 自加
a = 10
a += 1 # a = a + 1
print(a)
-= 自減
*= 自乘
a = 10
a *= 2  # a = a * 2
print(a)
/=
//=
**=
%=
          
        

邏輯運算符

          
            and (與/和)
or （或）
not （非）

print(3 and 4)
print(0 and 4)
print(0 and False)

and 都為真的時候取and后邊的值
and 都為假的時候取and前面的值
and 一真一假取假的

print(3 and 5 and 9 and 0 and False)
print(5 and False and 9 and 0)
print(1 and 2 and 5 and 9 and 6)

print(1 or 0)
print(1 or 2)
print(0 or False)

or 都為真的時候取or前邊的值
or 都為假的時候取or后面的值
or 一真一假取真的

print(1 or 9 or 4 or 0 or 9)
print(not False)

print(9 and 1 or not False and 8 or 0 and 7 and False)
          
        

成員運算符

          
            in  存在
not in 不存在

s = "alexdsb"
if "sb" not in s:
    print(True)
else:
    print(False)
          
        

總結(jié)

          
                運算順序：() > not > and > or 從左向右執(zhí)行
    算數(shù)運算符 ： + - * / // ** %
    比較運算符： > < >= <= == !=
    賦值運算符： = += -= *= /= //= **= %=
    邏輯運算符： and or not () > not > and > or
    成員運算符： in not in
          
        

4.編碼初始

理解

          
            今 0101
天 0110
晚 0010
上 0001
去 1001
便 1000
利 0100
店 1111

00000101  00000110  0010000110011001

linux -- utf-8
mac -- utf-8
windows -- gbk
          
        

四種（重要）

          
            ascii （老美）不支持中文
gbk    (國標) 英文 8位  中文16位
unicode （萬國碼）英文16 位 中文 32位
utf-8   （可變長的編碼） 英文8位 歐洲文 16位 亞洲24位
          
        

單位轉(zhuǎn)換

          
            1字節(jié) = 8位
1Bytes = 8bit ***
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
          
        

1.整形和布爾值的轉(zhuǎn)換

          
            整型 -- 數(shù)字 (int)
用于比較和運算的
32位 -2 ** 31 -1 ~ 2 ** 31 -1
64位 -2 ** 63 -1 ~ 2 ** 63 -1
+ - * / // ** %
          
        

          
            print(int("10101",2))  # 將二進制轉(zhuǎn)換成十進制
print(bin(21))         # 將十進制轉(zhuǎn)換成二進制
# 十進制轉(zhuǎn)二進制的算法  除2 取余,獲取的所有余數(shù)從下往上進行計算
# 二進制轉(zhuǎn)十進制的算法  從右向左,依次乘以2的次方
    1101  1* 2**0 + 0 * 2**1 + 1*2**2 + 1* 2**3
          
        

          
            python2  整型 int -- long(長整型)  /獲取的是整數(shù)
python3  整型 int   / 獲取的是浮點數(shù)(小數(shù))
          
        

          
            456    --- 十進制數(shù)
十六進制  八進制  二進制
二進制 -- 0101
          
        

          
            15  1
7   1
3   1
1   1

24    0
12    0
6     0
3     1
1     1

186     0
93      1
46      0
23      1
11      1
5       1
2       0
1       1
          
        

          
            print(bin(186))  # 十進制 -- 二進制
          
        

          
            56  0
28  0
14  0
7   1
3   1
1   1  #從下向上進行計算
print(bin(56))
          
        

          
            111000  # 從右向左進行計算
0 * 2 ** 0 + 0 * 2 ** 1 + 0 * 2 ** 2 + 1 * 2**3 + 1*2 ** 4 +1 * 2** 5
0 + 0 + 0 + 8 + 16 + 32

10101
1 * 2 ** 0 + 0 * 2**1 + 1* 2**2 + 0 * 2**3 + 1* 2 **4
1  +  0 + 4 + 0 + 16
          
        

          
            bool() 布爾值

print(bool(1))  # 數(shù)字非零的就是True 零就是False
print(bool("")) # 字符串不為空就是True ,字符串中沒有任何內(nèi)容就是False
總結(jié)：
    int 將二進制轉(zhuǎn)換成十進制
    bin 將十進制轉(zhuǎn)換成二進制
          
        

2.字符串詳解

          
                name = "meet"
    0123   從左向右
    -4-3-2-1  從右向左
    索引  通過索引可以精確定位到某個元素
    切片: [起始位置:終止位置]
    步長: 默認是1,通過步長可以決定方向和查找方式的邁的步子

          
        

          
            在python中引號引起來就是字符串
字符串是用來存儲少量數(shù)據(jù)
name = "meat"
meat 每一個字母叫做一個元素
      0123       從左向右
      -4-3-2-1    從右向左
      索引(下標) 通過索引可以精確的定位到某個元素
print(name[-1])

          
        

          
            name = "今天是個好日子"
       0 1 2 3 4 5 6
       -7-6-5-4-3-2-1
a = name[0]
b = name[1]
print(a+b)

print(name[0:2]) # 顧頭不顧尾  name[起始位置:終止位置]
print(name[:]) # 某個位置不指定的時候默認取最后或最前
print(name[2:5])
print(name[-2:-5])

print(name[-2:-5:-1]) # [起始位置:終止位置:步長] 步長默認為1

          
        

          
            name = "大黑哥吃大煎餅"
print(name[1:5])
print(name[-2:-6:-1])
print(name[-6:6])

a = name[0]
b = name[2]
c = name[4]
d = name[6]
print(a+b+c+d)
print(name[::2])

          
        

          
            print(name[100:105]) #切片的時候起始位置和終止位置都超出的時候不會進行報錯
print(name[100])  # 索引的時候索引值超出范圍的時候回報錯

          
        

字符串的方法:

          
                upper  全部大寫
    lower  全部小寫
    startswith  以什么開頭
    endswith   以什么結(jié)尾
    count    統(tǒng)計(計數(shù))
    strip    脫: 頭尾兩邊端的空格,換行以及制表符, 可以自己指定
    split    分割: 以空格,換行以及制表符進行分割,可以自己指定,可以指定切割的次數(shù)
    replace  替換: 第一個舊的值,第二是個新的值,可以指定替換的次數(shù)

          
        

          
            大寫小寫：
s = "ALEX"
s1 = s.upper() #全部大寫
print(s1)
s1 = s.lower() # 全部小寫
print(s1)
應用場景
s = input("驗證碼(AbC5)")
if s.upper() == "AbC5".upper():
    print("驗證碼正確")
else:
    print("驗證碼錯誤!")

          
        

          
            以什么開頭:
s = "ALEX"
s1 = s.startswith("E",2,6)
print(s1)

以什么結(jié)尾:
s = "ALEX"
s1 = s.endswith("X",3,4)
print(s1)

          
        

          
            統(tǒng)計：
s = "alexdxjbx"
s1 = s.count("x")
print(s1)

          
        

          
            脫: 字符串頭尾兩端的空格和換行符以及制表符
n = input(">>>")
if n.strip() == "alex":
    print("1")
else:
    print("2")
    
s = "alexdsba"
s1 = s.strip("a") # 可以指定內(nèi)容取脫
print(s1)

          
        

          
            分割:以空格和換行符以及制表符進行分割
s = "aelxlaaa"
s1 = s.split("l",maxsplit=1)  # 可以通過指定方式進行切割
print(s1)

          
        

          
            替換:
s = "大黑哥吃肉夾饃,肉夾饃"
s1 = s.replace("肉夾饃","大煎餅")
s1 = s.replace("肉夾饃","大煎餅",1) # 指定替換的次數(shù)
print(s1)

          
        

is 系列：

          
            s = "12.3"

print(s.isalnum()) # 判斷是不是字母,數(shù)字,中文
print(s.isalpha())  # 判斷是不是字母,中文
print(s.isdigit())  # 判斷字符串是不是全都是阿拉伯數(shù)字
print(s.isdecimal())  # 判斷是否是十進制

          
        

for 循環(huán)：

"""

你

好

啊

"""

          
            count = 0
while count < len(name):
    print(name[count])
    count += 1

name = "你好啊"
for x in name:  # for循環(huán)
    print(x)

name = "你好啊"
for i in name:  # for循環(huán)
    print(i)

          
        

          
            or 關鍵字
i 是變量名
in 關鍵字
name 可迭代對象

name = "alex"
for x in name:
    print(x)
print(x)

          
        

          
            錯誤的示范
name = True
for i in name:
    print(i)

數(shù)據(jù)類型中只有整型和布爾值不能夠進行for循環(huán)

          
        

總結(jié)：

          
                 for 變量 in 可迭代對象:
        print(變量)
    變量可以自己進行修改
len 獲取對象的長度

          
        

1.列表

列表 -- list -- 容器

          
            有序,可變,支持索引
列表: 存儲數(shù)據(jù),支持的數(shù)據(jù)類型很多 字符串,數(shù)字,布爾值,列表,集合,元祖,字典,

定義一個列表
lst = ["dsb",123,True,"黑哥"] # 用逗號分隔的是一個元素

print(lst[0])
print(id(lst[0]))
id獲取對象的內(nèi)存地址
          
        

          
            lst[0] = "dsb"
print(lst)  # ['dsb', 123, True, '黑哥']

s = "alex" # 字符串是不可變數(shù)據(jù)
s = "wusir"
s[0] = "b"
print(s)
          
        

增加

          
             append 追加
 insert 插入
 extend 迭代添加
          
        

          
            lst.append("大煎餅")  #追加(在列表的最后位置添加一個內(nèi)容)
print(lst)

lst.insert(2,"wusir")  #插入  以后盡量不要使用(當數(shù)據(jù)量比較大的時候會影響效率)
print(lst)

lst.extend("可迭代的內(nèi)容")  # 迭代添加
print(lst)
          
        

刪除

          
            del lst  -- 刪除整個列表
del lst[0] -- 通過索引刪除
del lst[1:2] -- 切片刪除
del lst[1:4:2] -- 步長刪除

clear 清空列表
remove 通過元素進行刪除

pop
  1.默認刪除最后一個
  2.有返回值返回的是被刪除的元素
  3.通過索引進行刪除
          
        

          
            lst.pop()  # 彈 -- 默認刪除最后一個
print(lst)

lst = ["dsb",123,True,"黑哥"]
lst.pop(2)   # 通過指定索引進行刪除
print(lst)

lst = ["dsb",123,"dsb",True,"黑哥"]
lst.remove("dsb") # 移除 -- 通過元素名字進行刪除
print(lst)

del lst[0]  # 通過索引刪除
print(lst)

del lst[0:3] # 通過切片刪除
print(lst)

del lst[0:3:2] # 通過步長刪除
print(lst)

lst.clear()  #清空
print(lst)
          
        

改

          
            lst[0] = 1
lst[1:2] ="qaaa"   # 元素可以超出切片的位數(shù)
lst[1:4:2] = "12"  # 元素和位置一一對應,多也不行少也不行
          
        

          
            lst = ["dsb",123,"dsb",True,"黑哥"]
lst[1] = "123"
print(lst)

lst = ["dsb",123,"dsb",True,"黑哥"]
lst[1:2] = "12345"
print(lst)

lst = ["dsb",123,"dsb",True,"黑哥"]
lst[1:4] = 12,13,14,15
print(lst)

lst = ["dsb",123,"dsb",True,"黑哥"]
lst[1:4:2] = "12"
print(lst)  # 步長不為1的必須用一一對應,多一個也不行,少一個也不行
          
        

查

          
            for i in lst:
    print(i)
    
for 循環(huán)
lst = ["dsb",123,"dsb",True,"黑哥"]
for i in lst:
    print(i)
          
        

列表的嵌套

          
            #取值通過索引進行取值,一層一層的進行查找

lst = [1,"alex","春生","小東北","渣弟",
       ["大黑哥",["常鑫",["自行車"],"大煎餅","掉井蓋","三金"],
    "馮強","海峰",["太白金星","女神","吳超",["肖鋒"]]]]
print(lst[-1][1][1][0])

a = lst[-1][-1][-2]
print(a)
不管什么類型進行切片的時候獲取都到都是源數(shù)據(jù)類型
          
        

2.元祖

元組 -- tuple

          
            有序,不可變,支持索引
元組用于存儲一些比較重要的信息
元組在配置文件中會使用
元組就是不可變的列表
          
        

定義的方式:

          
            tu = (1,"alex",True,"大黑哥",[1,2,3])
lst = [1,"alex",True,"大黑哥",[1,2,3]]
print(tu)

tu = (1,"alex",True,"大黑哥",[1,2,3])
print(tu[0:6])
          
        

          
             for 循環(huán)
 for i in tu:
     print(i)
          
        

3.range

          
            -*- coding:utf-8 -*-  [編碼]
range -- 范圍
print(list(range(0,10)))  # 顧頭不顧尾
          
        

          
                python3:
        range 是一個可迭代對象
    python2:
        xrange和python3中的range是相似的
        range返回一個列表
    range 范圍--是顧頭不顧尾
          
        

          
            print(list(range(0,10,1))) #步長不寫得時候默認為1  [0:10:1]
print(list(range(10,-2,-1))) #步長不寫得時候默認為1  [10:-2:-1]
print(list(range(10))) #步長不寫得時候默認為1  [:10]

print(list(range(0,10,1))) #步長不寫得時候默認為1  [0:10:1]
print(list(range(10,-2,-1))) #步長不寫得時候默認為1  [10:-2:-1]
print(list(range(10))) #步長不寫得時候默認為1  [:10]

range(起始位置,終止位置)  --  [起始位置:終止位置]
range(終止位置)  --  [:終止位置]
range(起始位置,終止位置,步長)  --  [起始位置:終止位置:步長]
          
        

          
            使用for循環(huán)和range 打印 100 ~ 1
for i in range(100,0,-1):
    print(i)

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

for i in range(0,101,2):
    print(i)

for i in range(0,101,6):
    print(i)

          
        

          
            錯誤示例:
while range(0,10):
    print(1)

lst = []
flage = True
while flage:
    name = input("請輸姓名:")
    lst.append(name)
    if len(lst) == 3:
        flage = False
print(lst)

lst = []
for i in range(3):
    lst.append(input("請輸入姓名:"))
print(lst)

          
        

          
            for 和 range配合使用

          
        

總結(jié)

1.while循環(huán) -- 死循環(huán)

          
            while 條件：    循環(huán)體
          
        

打斷死循環(huán)：

          
                break  -- 終止當前循環(huán)
    改變條件 -- 自動定義修改控制執(zhí)行次數(shù)
          
        

關鍵字：

          
                break  -- 終止當前循環(huán)
    continue -- 偽裝成循環(huán)體中最后一行代碼（官方：跳出本次循環(huán)，繼續(xù)下次循環(huán)）
while else：while條件成立的時候就不執(zhí)行了，條件不成立的時候就執(zhí)行else
          
        

2.字符串格式化：

          
                %  -- 占位
    %s -- 占字符串的位
    %d -- 占數(shù)字位
    %% -- 轉(zhuǎn)義成普通的%
    s = "你好%s"
    s%（"我好"）

    f"{變量名}{字符串}" 3.6版本及以上才能使用
          
        

3.運算符

          
                算數(shù)運算符 ： + - * / // ** %
    比較運算符： > < >= <= == !=
    賦值運算符： = += -= *= /= //= **= %=
    邏輯運算符： and or not () > not > and > or
    成員運算符： in not in
          
        

4.編碼

          
                編碼集（密碼本）
    ascii：
        不支持中文
    gbk：
        英文 8位  1字節(jié)
        中文 16位 2字節(jié)
    unicode：
        英文 16位 2字節(jié)
        中文 32位 4字節(jié)
    utf-8：
        英文 8 位 1字節(jié)
        歐洲 16位 2字節(jié)
        亞洲 24位 3字節(jié)
          
        

四種（重要）

          
            ascii （老美）不支持中文
gbk    (國標) 英文 8位  中文16位
unicode （萬國碼）英文16 位 中文 32位
utf-8   （可變長的編碼） 英文8位 歐洲文 16位 亞洲24位
          
        

單位轉(zhuǎn)換

          
            1字節(jié) = 8位
1Bytes = 8bit ***
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
          
        

1.整型和布爾值的轉(zhuǎn)換:

          
                bin -- 十進制轉(zhuǎn)二進制
    int("1101",2) -- 二進制轉(zhuǎn)十進制
    十進制轉(zhuǎn)二進制的算法
        除2 取余,獲取的所有余數(shù)從下往上進行計算

    二進制轉(zhuǎn)十進制的算法
        從右向左,依次乘以2的次方
         1101  1* 2**0 + 0 * 2**1 + 1*2**2 + 1* 2**3

    python2 中有l(wèi)ong /獲取的是整數(shù)
    python3 中只有int /獲取的是浮點數(shù)
          
        

2. 字符串的方法:

          
                name = "meet"
    0123   從左向右
    -4-3-2-1  從右向左
    索引  通過索引可以精確定位到某個元素
    切片: [起始位置:終止位置]
    步長: 默認是1,通過步長可以決定方向和查找方式的邁的步子
          
        

          
                upper  全部大寫
    lower  全部小寫
    startswith  以什么開頭
    endswith   以什么結(jié)尾
    count    統(tǒng)計(計數(shù))
    strip    脫: 頭尾兩邊端的空格,換行以及制表符, 可以自己指定
    split    分割: 以空格,換行以及制表符進行分割,可以自己指定,可以指定切割的次數(shù)
    replace  替換: 第一個舊的值,第二是個新的值,可以指定替換的次數(shù)
          
        

3.is系列:

          
                str.isdigit # 判斷是不是阿拉伯數(shù)字
    str.isdecimal # 判斷是不是十進制數(shù)
    str.isalnum # 判斷是不是字母,數(shù)字,漢字
    str.isalpha # 判斷是不是字母,中文
          
        

4. for循環(huán)

          
                for 變量 in 可迭代對象:
        print(變量)
    變量可以自己進行修改
len 獲取對象的長度
          
        

5.面試

          
            for i in "alex":
    pass
print(i) # x
pass / ... 占位
          
        

列表 -- list

          
            有序,可變的,索引,
作用:存儲數(shù)據(jù)的,支持很多種數(shù)據(jù)類型
          
        

          
            定義方式:
lst = [1,"alex","黑哥"]
          
        

          
            增:
 append 追加
 insert 插入
 extend 迭代添加
          
        

          
            刪
del lst  -- 刪除整個列表
del lst[0] -- 通過索引刪除
del lst[1:2] -- 切片刪除
del lst[1:4:2] -- 步長刪除

clear 清空列表
remove 通過元素進行刪除

pop
  1.默認刪除最后一個
  2.有返回值返回的是被刪除的元素
  3.通過索引進行刪除
          
        

          
            改
lst[0] = 1
lst[1:2] ="qaaa"   # 元素可以超出切片的位數(shù)
lst[1:4:2] = "12"  # 元素和位置一一對應,多也不行少也不行
          
        

          
            查
for i in lst:
    print(i)
          
        

          
            列表的嵌套:
取值通過索引進行取值,一層一層的進行查找
          
        

2.元組 -- tuple

          
              只能索引查看和for查看,不能進行增刪改
  存儲一些重要的信息數(shù)據(jù)
  元組在配置文件中會使用
  元組是不可變的列表
          
        

3.range -- 范圍

          
                python3:
        range 是一個可迭代對象
    python2:
        xrange和python3中的range是相似的
        range返回一個列表
    range 范圍--是顧頭不顧尾
          
        

          
            print(list(range(0,10,1))) #步長不寫得時候默認為1  [0:10:1]
print(list(range(10,-2,-1))) #步長不寫得時候默認為1  [10:-2:-1]
print(list(range(10))) #步長不寫得時候默認為1  [:10]
          
        

          
            range(起始位置,終止位置)  --  [起始位置:終止位置]
range(終止位置)  --  [:終止位置]
range(起始位置,終止位置,步長)  --  [起始位置:終止位置:步長]
          
        

          
            for 和 range配合使用