Python基础二

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配合使用

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券