1.while循环
while -- 关键字 (死循环)
基本结构
if 条件:
结果
while 条件：
循环体
while True: #真 执行
print("A")
print("B")
print("C")
print("D")
print("E")
print("F")
print("G")
while False: # 假 不执行
print("A")
print("B")
print("C")
print("D")
print("E")
print("F")
print("G")
print(1)
while False: # 假 执行不到
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))
数字中非零的的都是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 #终止当前循环 birak下方的代码不执行
print(C)
print(D)
while True:
print(A)
print(B)
continue #伪装成临时当作循环体中的最后一行代码(跳出当前循环继续下一个循环)
#下面代码不会执行
print(C)
print(D)
while else
while True:
print(E)
else:
print(F)
while True:
print(A)
break
print(B)
总结
打断循环的方式：
1.自己修改条件
2.break
break ——打破当前循环（终止当前循环）
continue ——跳出当前循环继续下次循环（伪装成临时当作循环体中的最后一行代码）
break和continue相同之处：他们一下的代码都不执行
练习
代码：25——57——25
def func(x):
print(x)
if x < 57:
x += 1
func(x)
print(x - 1)
func(25)
代码：循环
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.字符串格式化
内容
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)
总结
%s 是占的字符串类型的位置
%d 是占的数字类型的位置
%% 转换成普通的%号
按照位置顺序传递,占位和补位必须要一一对应
3.运算符
运算顺序
() > not > and > or
从左向右执行
算数运算符
+
-
*
/ python2获取的值是整数，python3获取的是浮点数（小数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)
总结
运算顺序：() > not > and > or 从左向右执行
算数运算符 ： + - * / // ** %
比较运算符： > < >= <= == !=
赋值运算符： = += -= *= /= //= **= %=
逻辑运算符： 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位
单位转换
1字节 = 8位
1Bytes = 8bit ***
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
1.整形和布尔值的转换
整型 -- 数字 (int)
用于比较和运算的
32位 -2 ** 31 -1 ~ 2 ** 31 -1
64位 -2 ** 63 -1 ~ 2 ** 63 -1
+ - * / // ** %
print(int("10101",2)) # 将二进制转换成十进制
print(bin(21)) # 将十进制转换成二进制
# 十进制转二进制的算法 除2 取余,获取的所有余数从下往上进行计算
# 二进制转十进制的算法 从右向左,依次乘以2的次方
1101 1* 2**0 + 0 * 2**1 + 1*2**2 + 1* 2**3
python2 整型 int -- long(长整型) /获取的是整数
python3 整型 int / 获取的是浮点数(小数)
456 --- 十进制数
十六进制 八进制 二进制
二进制 -- 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)) # 数字非零的就是True 零就是False
print(bool("")) # 字符串不为空就是True ,字符串中没有任何内容就是False
总结：
int 将二进制转换成十进制
bin 将十进制转换成二进制
2.字符串详解
name = "meet"
0123 从左向右
-4-3-2-1 从右向左
索引 通过索引可以精确定位到某个元素
切片: [起始位置:终止位置]
步长: 默认是1,通过步长可以决定方向和查找方式的迈的步子
在python中引号引起来就是字符串
字符串是用来存储少量数据
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 以什么结尾
count 统计(计数)
strip 脱: 头尾两边端的空格,换行以及制表符, 可以自己指定
split 分割: 以空格,换行以及制表符进行分割,可以自己指定,可以指定切割的次数
replace 替换: 第一个旧的值,第二是个新的值,可以指定替换的次数
大写小写：
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)
以什么结尾:
s = "ALEX"
s1 = s.endswith("X",3,4)
print(s1)
统计：
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") # 可以指定内容取脱
print(s1)
分割:以空格和换行符以及制表符进行分割
s = "aelxlaaa"
s1 = s.split("l",maxsplit=1) # 可以通过指定方式进行切割
print(s1)
替换:
s = "大黑哥吃肉夹馍,肉夹馍"
s1 = s.replace("肉夹馍","大煎饼")
s1 = s.replace("肉夹馍","大煎饼",1) # 指定替换的次数
print(s1)
is 系列：
s = "12.3"
print(s.isalnum()) # 判断是不是字母,数字,中文
print(s.isalpha()) # 判断是不是字母,中文
print(s.isdigit()) # 判断字符串是不是全都是阿拉伯数字
print(s.isdecimal()) # 判断是否是十进制
for 循环：
"""
你
好
啊
"""
count = 0
while count < len(name):
print(name[count])
count += 1
name = "你好啊"
for x in name: # for循环
print(x)
name = "你好啊"
for i in name: # for循环
print(i)
or 关键字
i 是变量名
in 关键字
name 可迭代对象
name = "alex"
for x in name:
print(x)
print(x)
错误的示范
name = True
for i in name:
print(i)
数据类型中只有整型和布尔值不能够进行for循环
总结：
for 变量 in 可迭代对象:
print(变量)
变量可以自己进行修改
len 获取对象的长度
1.列表
列表 -- list -- 容器
有序,可变,支持索引
列表: 存储数据,支持的数据类型很多 字符串,数字,布尔值,列表,集合,元祖,字典,
定义一个列表
lst = ["dsb",123,True,"黑哥"] # 用逗号分隔的是一个元素
print(lst[0])
print(id(lst[0]))
id获取对象的内存地址
lst[0] = "dsb"
print(lst) # ['dsb', 123, True, '黑哥']
s = "alex" # 字符串是不可变数据
s = "wusir"
s[0] = "b"
print(s)
增加
append 追加
insert 插入
extend 迭代添加
lst.append("大煎饼") #追加(在列表的最后位置添加一个内容)
print(lst)
lst.insert(2,"wusir") #插入 以后尽量不要使用(当数据量比较大的时候会影响效率)
print(lst)
lst.extend("可迭代的内容") # 迭代添加
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" # 元素可以超出切片的位数
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 循环
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)
不管什么类型进行切片的时候获取都到都是源数据类型
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 循环
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循环和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配合使用
总结
1.while循环 -- 死循环
while 条件： 循环体
打断死循环：
break -- 终止当前循环
改变条件 -- 自动定义修改控制执行次数
关键字：
break -- 终止当前循环
continue -- 伪装成循环体中最后一行代码（官方：跳出本次循环，继续下次循环）
while else：while条件成立的时候就不执行了，条件不成立的时候就执行else
2.字符串格式化：
% -- 占位
%s -- 占字符串的位
%d -- 占数字位
%% -- 转义成普通的%
s = "你好%s"
s%（"我好"）
f"{变量名}{字符串}" 3.6版本及以上才能使用
3.运算符
算数运算符 ： + - * / // ** %
比较运算符： > < >= <= == !=
赋值运算符： = += -= *= /= //= **= %=
逻辑运算符： and or not () > not > and > or
成员运算符： in not in
4.编码
编码集（密码本）
ascii：
不支持中文
gbk：
英文 8位 1字节
中文 16位 2字节
unicode：
英文 16位 2字节
中文 32位 4字节
utf-8：
英文 8 位 1字节
欧洲 16位 2字节
亚洲 24位 3字节
四种（重要）
ascii （老美）不支持中文
gbk (国标) 英文 8位 中文16位
unicode （万国码）英文16 位 中文 32位
utf-8 （可变长的编码） 英文8位 欧洲文 16位 亚洲24位
单位转换
1字节 = 8位
1Bytes = 8bit ***
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
1.整型和布尔值的转换:
bin -- 十进制转二进制
int("1101",2) -- 二进制转十进制
十进制转二进制的算法
除2 取余,获取的所有余数从下往上进行计算
二进制转十进制的算法
从右向左,依次乘以2的次方
1101 1* 2**0 + 0 * 2**1 + 1*2**2 + 1* 2**3
python2 中有long /获取的是整数
python3 中只有int /获取的是浮点数
2. 字符串的方法:
name = "meet"
0123 从左向右
-4-3-2-1 从右向左
索引 通过索引可以精确定位到某个元素
切片: [起始位置:终止位置]
步长: 默认是1,通过步长可以决定方向和查找方式的迈的步子
upper 全部大写
lower 全部小写
startswith 以什么开头
endswith 以什么结尾
count 统计(计数)
strip 脱: 头尾两边端的空格,换行以及制表符, 可以自己指定
split 分割: 以空格,换行以及制表符进行分割,可以自己指定,可以指定切割的次数
replace 替换: 第一个旧的值,第二是个新的值,可以指定替换的次数
3.is系列:
str.isdigit # 判断是不是阿拉伯数字
str.isdecimal # 判断是不是十进制数
str.isalnum # 判断是不是字母,数字,汉字
str.isalpha # 判断是不是字母,中文
4. for循环
for 变量 in 可迭代对象:
print(变量)
变量可以自己进行修改
len 获取对象的长度
5.面试
for i in "alex":
pass
print(i) # x
pass / ... 占位
列表 -- list
有序,可变的,索引,
作用:存储数据的,支持很多种数据类型
定义方式:
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" # 元素可以超出切片的位数
lst[1:4:2] = "12" # 元素和位置一一对应,多也不行少也不行
查
for i in lst:
print(i)
列表的嵌套:
取值通过索引进行取值,一层一层的进行查找
2.元组 -- tuple
只能索引查看和for查看,不能进行增删改
存储一些重要的信息数据
元组在配置文件中会使用
元组是不可变的列表
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配合使用
