python运算符、if判断、while、for循环、字符串相关函数

### 运算符
# （1） 算数运算符: + - * / // % **
var1 = 10
var2 = 7
res = var1 + var2
print(res)
res = var1 - var2
print(res)
res = var1 * var2
print(res)
res = var1 / var2 # 1.4285714....
print(res)
# // 地板除 整出之后的数
# 如果被除数 或者 除数是一个小数，那么结果后面加一个小数
res = var1 // var2
print(res)
res = 14.3 // 7
print(res)
res = 8 % 3 # 正常取余
print(res)
res = -8 % 3 # -2 + 3 = 1
# 如果8 前面带负号，那么余数也带上符号
print(res)
res = 8 % -3 # 2 + (-3) = -1
# 如果3 前面带负号，那么正常取余后的数与-3相加
print(res)
res = -8 % -3
# 如果两者符号都是负号 直接取余数 跟上负号
print(res)
res = 3 ** 2
print(res)
res = 2 ** 4
print(res)
# (2) 比较运算符 > < >= <= == !=
# 返回一个布尔类型的值 True False
var1 = 5
var2 = 3
res = var1 > var2
print(res)
res = var1 != var2 # 不等于
print(res)
# (3) 赋值运算符 = -= *= /= //= %= **=
var1 = 8
var2 = 3
var1 *= var2
# 相当于var1 = var1 * var2
print(var1)
var1 /= var2
# 相当于 var1 = var / var2
print(var1)
var1 //= var2
print(var1)
var1 %= var2
print(var1)
var1 = 4
var1 **= 3 # 4 * 4 * 4 = 64
print(var1)
# (4) 成员运算符 in 和 not in (针对容器类型数据)
# str 必须是一个连续的片段
strvar = "你很好，我也会更好"
res = "你" in strvar
print(res)
res = "嘿" in strvar
print(res)
# list tuple set
listvar = ["嗨","嘿","哈","嗷"]
res = "嗨" not in listvar
print(res)
setvar = {"楚雨荨","韩信","鲁班"}
res = "韩信" in setvar
print(res)
tuplevar = ("嫦娥","后羿","八戒")
res = "嫦娥" not in tuplevar
print(res)
# dict 成员运算符 判断字典时 判断的是键 不是所对应的值
dictvar = {"top": "程咬金", "bottom": "李元芳", "middle": "貂蝉"}
res = "程咬金" in dictvar # 成员运算符 判断字典时 判断的是键 不是所对应的值
print(res) # False
res = "top" in dictvar
print(res)
print("-----------")
#### 身份运算符 is | is not 检测两个数据在内存中是否是同一个地址
# 3.6版本之前 整型 -5 ~ 正无穷
var1 = 19
var2 = 19
res = var1 is var2
print(res)
# 浮点型 非负数
var1 = -5.52
var2 = -5.52
res = var1 is  var2
print(res)
print("?浮点型负数为什么在同一个地址")
# 复数 在实数 + 虚数 这样的结构中永远不一样 但如果只有虚数 在值相同的情况下一样
var1 = 3 + 4j
var2 = 3 + 4j
res = var1 is var2
print(res)
print("为什么在 实数 + 虚数 这样的结构中是一样")
var1 = 6j
var2 = 6j
res = var1 is var2
print(res)
# bool 在布尔值相同的情况下 id 一样
var1 = True
var2 = True
res = var1 is var2
print(res)
# 容器类型数据地址判断
# str 字符串而言, 字符串值相同的情况下, id一致, 值一样
# 列表，元组，字典，集合 无论什么情况 id表示都不同 (但空元组的id标识一样)
var1 = "你"
var2 = "你"
# res = var1 is var2
# print(res)
print(var1 is var2)
# 例: 但是空元组例外
var1 = ()
var2 = ()
print(var1 is var2)
# 逻辑运算符 and 逻辑与 or 逻辑或 not 逻辑非 [相当于取反]
res = True and True
print(res)
res = True and False
print(res)
res = not True
print(res)
res = not False
print(res)
# 逻辑短路
# (1) True or something
# (2)False and something
print("<==>")
False or print(123)
True and print(456)
# 逻辑优先级: () > not > and > or
res = 5 or 6 and 7 # 有优先级的问题， 还有短路的问题
print(res) # 5
res = (5 or 6) and 7
print(res)
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
print(res)
res = 1 < 2 and 3 > 5 or 6 # False or True => 6
print(res)
res = 1 < 2 and 3 > 4 or 5 > 6 and 7 < 8 or 9 > 10 # False or False => 直接打印False
print(res)
# 这种情况特殊，上来直接短路，后面的不用按照and or 优先级计算了
res = 5 or 6 and 7 or 8 and 9 or 10
print(res)
# 如果上来直接是假， 不一定结果也是假，要依次向后计算
print("为什么上来直接短路？")
# 数据类型判断 isinstance
# int float bool complex str list tuple set dict
# isinstance (要判断类型的数据, (类型1, 雷星2, 类型3......))") 如果在类型元组当中, 返回真, 不在返回假
intvar = 15
print(isinstance(intvar,dict))
strvar = "789"
print(isinstance(strvar,(int,str,list))) # 在(int,str,list)当中，如果有，就返回真
# 位运算符: &--按位与 |--按位或 ~--按位非 ^--按位异或 <<--左移 >>--右移
var1 = 19 # 二进制: 00010011
var2 = 15 # 二进制: 00001111
res = var1 & var2 # &--按位与
# 10011
# 01111
# 00011---> 011 是 3
print(res)
res = var1 | var2 # |--按位或
# 10011
# 01111
# 11111
print(res)
res = 5 << 2 # <<--左移 5*2^2
# 0000 0101
# 0001 0100 向左移动两位
""" n << m n乘以2的m次幂 """
print(res)
res = 5 >> 1
'''n >> m n除以2的m次幂 '''
print(res)
res = var1 ^ var2 # ^--按位异或
'''两个值不同方为真1， 两个值相同为假0'''
print(res) # 11100 --> 28
res = ~19 # ~--按位非
''' -(n+1) '''
print(res)
"""
运算符的优先级
一元运算符: 同一时间之操作一个数字运算的( ~ - )
二元运算符: 同一时间之操作两个数字运算符的( + - * / )
整体一元运算符优先级大于二元运算符
所有运算符当中 ** 幂运算优先级最高 3 ** 4
所有运算符当中 = 赋值运算符优先级最低
乘除 > 加减
() > not > and > or
~ > ( << >> ) > & > ^ > |
除此之外，剩下的运算符优先级如下:
算术运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符 单独拿出来作为最后， 把值计算好之后再进行赋值
"""
res = 5 + 5 << 6 // 3 is 40 and True
print(res)
### 循环判断
# 代码块 : 以冒号作为开始，用缩进来划分区域，这个整体叫代码块
# 作用域 : 作用区域，作用范围
# 代码执行顺序 : 默认从上到下
'''
if循环
'''
if 5 == 6 :
    # print(a) error: python
    print(666)
    print(888)
    print(90)
print(4) # 缩进划分区域
# 写缩进的时候，要注意四个空格和一个Tab不要混合
# 在其它语言里，划分作用于的是{}而不是缩进代码块
# 流程 : 代码执行的流程
# 流程控制 : 对代码执行过程的管控
yangqichao = "大傻逼"
if yangqichao == "大傻逼":
    print("我就是小傻逼")
else:
    print("我是他宝")
# input 等待用户输入内容
res = input("欢迎，你叫什么名字")
print(res)
username = input("输入你的用户名")
pwd = input("输入你的密码")
print(username,type(username))
print(pwd,type(pwd))
if username == "admin" and pwd == "000":
    print("恭喜，登陆成功")
else:
    print("抱歉，用户hi名或者密码有误")
"""
while循环
"""
i = 0
sum = 0
while i <= 100:
    # 写逻辑在此处...
    print(i)
    i += 1
    sum += i
    print(sum)
"""
字符串的相关操作
"""
# (1) 字符串的拼接
str1 = "爱你"
str2 = "超超"
res = str1 + str2
print(res)
str1 += str2
print(str1)
# (2) 字符串的重复
str1 = "三遍"
res = str1 * 3
print(res)
str1 *= 3
print(str1)
# (3) 字符串的跨行拼接
strvar = "是的法师" \
         "2222" \
         "321" # 回车键
print(strvar)
# (4) 字符串的索引
#         0--------->6
strvar = "一二三四五六七"
#        -8--------->-1
res = strvar[6]
print(res)
"""
(5) 字符串的切片
 语法 ==> 字符串[::] 完整格式:[开始索引:结束索引:间隔值]
 [开始索引:] 从来是索引截取到字符串的最后
 [:结束索引] 从开头截取到结果索引之前(结束索引-1)
 [开始索引:结束索引] 从开始索引截取到结果索引之前(结束索引-1)
 [开始索引:结束索引:间隔值] 从开始索引截取到结果索引之前按照指定的间隔截取字符
 [:]或[::] 截取所有字符串
"""
# 字符串的切片简而言之就是字符串的截取操作
strvar = "五一假期，国家法定多放假了一天，大家普天同庆，一起欢度美好时光"
# [开始索引:] 从来是索引截取到字符串的最后
res = strvar [23:]
print(res)
#  [:结束索引] 从开头截取到结果索引之前(结束索引-1)
res = strvar [:3]
print(res) # 只打印五一假，最高位取不到 ---> 结束索引-1
res = strvar [1::2] #理解: 间隔值-1
print(res) # 一期国法多假一，家天庆一欢美时
res = strvar[-32::2]
print(res) # 同上
res = strvar[-1::-2] #理解: 同上
print(res) # 光好度起，同普大天了放定家，假五


sign = True
total = 0
i = 0
while sign:
    total += i
    i += 1
    if i == 101:
        sign = False
print(total)

a = 0
while a < 100:
    # a += 1
    if a % 2 == 0: #?
        print("?",end = " ")
    else:
        print("?",end = " ")
    if a % 10 == 9:
        print()
    a += 1 # 不要放在前面
# (5) 一个循环,打印十行十列隔列变色小星星
x = 0
while x < 100:
    if x % 2 == 0:
        print("?",end="")
    else:
        print("?",end="")
    # 最后换行
    if x % 10 == 9:
        print()
    x += 1
        # 打印换行
# (6) 一个循环,打印十行十列隔行变色小星星 地板除算法//
"""
地板除算法
0 // 10 0
1 // 10 0
2 // 10 0
3 // 10 0
4 // 10 0
...
9 // 10 0
10 //10 1
11 //10 1
...
19 // 10 1
20 // 10 2
"""
w = 0
while w < 100:
    # 利用地板除与取余的规律，产生十个相同的数字，并且按十个相同的余数取花色
    if w // 10 % 2 == 0:
        print("?",end = "")
    else:
        print("?",end = "")
    # 控制换行
    if  w  % 10 == 9:
        print()
    w += 1
# 字符串的格式化 (%d %f %s 占位符)
"""
”字符串“ % (要替换的值)
"""
# %d 整形占位符
strvar = "今天买了%d个苹果" % (3)
print(strvar)
# %f 浮点型占位符
strvar = " 我花了%.4f元" % (2.3414) # 保留小数点遵循四舍五入
print(strvar)
# %s 字符串占位符
strvar = "%s" % ("我最帅")
print(strvar)
# 九九乘法表
q = 0
while q <=9:
    #print(q)
    j = 1 # 3*1 3*2 3*3 在一行
    while j <= q:
        print("%d * %d =%2d" % (q,j,q*j),end="  ")
        j += 1
    # 执行换行
    print()
    q += 1
    j = 1
    while j <=i:
        print("%d * %d =%2d" % (i,j,i * j))
        j += 1
    print()
    i -= 1
# 100 ~ 999 找吉利数字 111 222 123 321 888 ...
"""
n = 567
n // 100 => 5 百位
n // 10 % 10 => 6 十位
n % 10 => 7 个位
"""
i = 100
while i <= 999:
    baiwei = i // 100
    shiwei = i // 10 % 10
    gewei = i % 10
    if shiwei == gewei and shiwei == baiwei :
        print(i) # 111 222
    if shiwei == gewei -1 and shiwei == baiwei + 1:
        print(i) # 123 456
    if shiwei == gewei +1 and shiwei == baiwei - 1:
        print(i) # 987 654
    i += 1
# 百元买百鸡 公鸡一块钱一只 母鸡三块钱一只 小鸡五毛钱一只 买100只鸡 有多少种买法
"""
穷举法
a => (1,2)
b => (3,4)
c => (5,6)
a + b + c == 10
x + y + z == 100 and x + y * 3 + 0.5 * z = 100
"""
# f 公鸡 y 母鸡 z小鸡
f = 0
while f <= 100:
    y = 0
    while y <= 33:
        z = 0
        while z <= 100:
            if(f + y + z == 100) and (f + y * 3 + 0.5 * z == 100):
                print(f,y,z)
            z += 1
        y += 1
    f += 1
# ### for循环 特质用于遍历容器类型数据
# while循环有局限性 不能遍历无序容器数据
setvar = ("a","b","c","d")
# i = 0
# length = len(setvar)
# while i <= length:
#     print(setvar[i])      error
"""
for i in 可迭代性数据：把可迭代数据中的值一个一个拿出来复制给i
"""
for i in setvar:
    print(i)
# 遍历字符串
strvar = "今天我最棒"
for i in strvar:
    print(i)
# 遍历列表
listvar = [1,2,3,4,5,6]
for i in listvar:
    print(i)
# 遍历元组
tuplevar = (6,7,8,7)
for i in tuplevar:
    print(i)
# 遍历集合
for i in setvar:
    print(i)
# 遍历字典 在遍历字典时 默认遍历的是键，不是值
dictvar = {'z':1,'y':2,'x':3}
for i in dictvar:
    print(i)
# 二级容器
lst= [1,2,3,(4,5,6)]
res = lst [-1]
res = res [-1]
print(res,"<22>")
# 二级元组
tuplevar = (1,2,3,(4,5,6))
print(tuplevar)
# 二级列表
listvar = [1,2,3,[4,5,6]]
print(listvar)
# 二级字典
dic ={"a":1,"b":{"c":4,"d":5}}
print(dic["b"]),"<33>"
# 二级集合：集合中的数据必须是可哈希数据（不可变数据）
set1 ={1,2,3,4,(1,2,3)}
# 多级容器
lst = [1,2,3,4,[5,6,(11,123,{"c":22,"f":33},34),7,8]]
# 找出33
res = lst[-1][2][2]["f"]
print(res,"<3333>")

# 变量的解包操作
a,b = 1,2
c,d = [5,6]
print(a,b,c,d,"<4444>")
### 遍历等长的二级容器，里面的元素是容器数据，容器里面的元素个数相同
listvar = [["王健林","王思聪",],["马云","马化腾"],["王宝强","马蓉"]]
for a,b in listvar:
    print(a,b)
# 不等长的二级容器（老老实实一层一层遍历）
listvar = [["王健林","王思聪",],["马云","马化腾"],["王宝强","马蓉"]]
for i in listvar:
    for j in i:
        print(j)
"""
range的用法:返回上一个可迭代的对象
range(start,end,step)
start 代表开始值 
end 代表结束值 但是高位取不到 取到之前的一个值
step 步长
"""
# 只有一个参数的情况:
for i in range(8): # 0~7
    print(i)
# 有两个参数的情况
for i in range(5,8): # 5,6,7
    print(i)
# 有三个参数的情况 (正序)
for i in range (1,11,3): #
    print(i)
print("--------")
for i in range(9,0,-1):
    print(i)

# ### 字符串相关函数
# *capitalize 字符串首字母大写
# strvar = "oh Father this is My Favarate boY"
strvar = "this is a dog"
res = strvar.capitalize()
print(res)
# *title 每个单词的首字母大写（非字母隔开的单词）
# strvar = "this is a dog"
res = strvar.title()
print(res)
# *upper 将所有字母变成大写
res = strvar.upper()
print(res)
# *lower 将所有字母变成小写
res = strvar.lower()
print(res)
# *swapcase 大小写互换
res = strvar.swapcase()
print(res)
# *count   统计字符串中某个元素的数量
strvar = "aa bb cc"
res = strvar.count("a")
print(res)
# *find 查找某个字符串第一次出现的索引位置
'''find('字符串'，开始位置，结束位置)（结束位置取不到，取到结束位置-1）'''
print("===find===")
strvar = "oh Father this is My Favarate boY"
res = strvar.find("F") # 3
print(res)
res = strvar.find("F",4) # 21
print(res)
res = strvar.find("F",10,20)
print(res)
res = strvar.find("aa")
print(res)
# *index 与 find 功能相同 find找不到-1，index找不到数据直接报错[推荐使用find]
# *startswith 判断是否以某个字符或者字符串开头
'''startswith ('字符串'，开始位置，结束位置)（结束位置取不到，取到结束位置-1）'''
strvar = "oh Father this is My Favarate boY"
res = strvar.startswith("oh")
print(res)
res = strvar.startswith("Fa")
print(res)
res = strvar.startswith("thi",10)
print(res)
# *endswith 判断是否以某个字符或者字符串结尾
'''endswith ('字符串'，开始位置，结束位置)（结束位置取不到，取到结束位置-1）'''
res = strvar.endswith("boY")
print(res)
res = strvar.endswith("bo",-4,-1)
print(res)
print("不理解")
# ***split 按某字符将字符串分割成列表（默认从左到右按空格分割）
strvar = " you can you up no can no bb"
res = strvar.split()
print(res)
strvar = "you = can = you = up = no = bb"
res = strvar.split("=",2)
print(res) # ['you ', ' can ', ' you = up = no = bb']
# rsplit 从右向左分割
res = strvar.split("=",1)
print(res) # ['you ', ' can = you = up = no = bb']
# ****join 按某字符将列表拼接成字符串（容器类型都可）
listvar = ['you','can',"a","basestring"]
res = "*".join(listvar)
print(res) # 返回字符串
# *replace 替换字符串（第三个参数选择替换的次数）
strvar = "可爱的小狼狗喜欢吃肉，有没有，有没有，还有没有"
res = strvar.replace("有没有","真没有")
print(res)
# 第三个参数选择替换的次数
res = strvar.replace("有没有","真没有",1)
print(res)
# *isdecimal 检测字符串是否以数字组成 必须是纯数字
res = "11323"
print(res.isdecimal())
# *len 计算容器类型长度
res = len("aabbcc")
print(res)
# *center 填充字符串，原字符居中（默认填充空格）
strvar = "你"
res = strvar.center(10,"*") # center(填充的个数，填充的字符)
print(res) # ****你*****
# *strip 默认去掉首尾两边的空白符
strvar = "\r sdf \t \n"
print(strvar)
res = strvar.strip()
print(res)