python基础篇

number_1=10
number_2=10
res = number_1 == number_2
print(res)
#True

登录判断

# 登录判断
user = "root"
passwd = 123

username = input("请输入用户名:")
userpasswd = input("请输入密码:")
print(user == username and userpasswd == passwd)
# 结果：
# 请输入用户名:123
# 请输入密码:456
# False

!=

number_1=10
number_2=20
res = number_1 != number_2
print(res)
#True

<=

number_1=10
number_2=20
res = number_1 <= number_2
print(res)
#True

判断奇偶数

num = 23
print(num % 2 == 0)
#False

逻辑运算符

and

a = 10
b = 20
print(a == 10 and b == 20)
#True

or

a = 10
b = 20
print(a == 10 or b == 40)
#True

not

成员运算符 in

print(f"判断5在不在元素里面:{5 in [1, 2, 3]}")  # 判断5在不在元素里面:False

条件嵌套

a = 10
b = 20
ab = 30
print(ab > 40 or (a >10 and b >10))#False
print(ab >= 30 or (a >10 and b >10))#True

运算符优先级

高级数据类型

列表[ ]()

• 对存储的格式没有任何要求
• 是一个可以变化的数据类型

创建列表

写法1 直接写[] 
写法2 () 都可以

#方法1：直接赋值
namelist = []
print(namelist,type(namelist))

namelis1 = ["王建","张三"]
print(namelis1)
#打印元素,及类型
print(namelist1[0],type(namelist1[0]))

#方法2：通过list()函数
a = list()
print(a,type(a))
b = list("王建")
print(b)
c = list(range(10))
print(c)
d = list(range(2,-3,-1))
print(d)

方法3：通过列表推导式创建列表
e = [x*2 for x in range(5)]
print(e)

遍历列表元素

#打印遍历元素
namelist = ["小张","小王","小李"]
for name in namelist:
    print(name)
# 小张
# 小王
# 小李

namelist = ["小张","小王","小李"]
i = 0
while i < len(namelist):
    print(namelist[i])
    i += 1

列表元素操作

#列表切片
list2 = [10,20,30,40,50]
print(list2[0]) #打印第一个元素
print(list2[0:3]) #打印前三个元素
print(list2[2:5:1]) #打印2-5之间的元素，步进为1
lst = ["192.168.1.1", "192.168.1.2", "192.168.1.3"]

ip1 = lst[0: 2]  # 取出第一个和第二个元素['192.168.1.1', '192.168.1.2']
ip2 = lst[::-1]  # 倒着显示['192.168.1.3', '192.168.1.2', '192.168.1.1']


namelist = ["小张","小王","小李"]
print(max(namelist))
print(min(namelist))

#求和
list = [10,20,30]
print(sum(list))

在末尾添加append

#增追加append,在末尾,append是没有返回值的
namelist = ["小张","小王","小李"]
print("--------增加前数据------")
for name in namelist:
    print(name,end="\t")
# nametemp = input("\n请输入增加的名字:")
# namelist.append(nametemp)
namelist.append("小付")
print("")
print("--------增加后数据------ ")
for name in namelist:
    print(name,end="\t")

合并列表

a = [1,2]
b = [3,4]
a.append(b) #讲列表当做一个元素，加入到a列表中
print(a)
[1, 2, [3, 4]]

#extend 将b的数据添加到a
a = [1,2]
b = [3,4]
a.extend(b)
print(a)
[1, 2, 3, 4]

#+操作
a = [10,20,30]
b = [40,50]
res = a + b
print(res)
[10, 20, 30, 40, 50]


#[*]操作
a = [10,20,30]
b = a * 3
print(b) 
[10, 20, 30, 10, 20, 30, 10, 20, 30]


#合并两个列表中的数据
lst1.extend(lst)#两个列表lst1和lst的里面的数据合并，['c', 'a', 'b', '192.168.1.1', '192.168.1.2', '192.168.1.3']

insert指定位置插入

#insert插入
a = [10,20,30]
a.insert(1,3) #第一个变量表示下表，第二个表示元素
print(a)
[10, 3, 20, 30]

删除元素

#del 删除  pop 弹出 remove 移除（第一次出现的）
a = [10,20,30]
#del a[1] #删除下表为1的值
#a.pop() #默认会把最后一个值，弹出，有返回值
#tanchu = a.pop(0) #把下标为0的值弹出 删除第一个元素,这个可以有返回值，知道是谁被删除了
#print("被弹出的元素是：",tanchu)
#print(a)
a.remove(10) #直接删除某个值，如果有重复的值，默认删除第一个，没有返回值
print(a)

删除整个列表

a = ["张三","李四"]
a.clear()
print(a)
#[]

修改元素

a = [10,20,30]
a[1] = 100 #修改下标为1的元素，值为100
print(a) #[10, 100, 30]

查找元素

a = ["王","李"]
chazhao = input("请输入你要查找的数字: ")
if chazhao in a:
    print("你在元素中找到的数据")
else:
    print("没有找到")

a = ["a","b","c","d"]
print(a.index("a"))  #拿到a的下标
print(a.index("b",1,4))  #拿到a的下标,从第一个位置开始，第4个位置结束

a = ["a","b","c","d"]
print(a.count("a")) #查找a出现了几次

排序和反转

number_list = [1,3,2,4,6,5]
number_list.sort()#升序
print(number_list)#[1, 2, 3, 4, 5, 6]

number_list = [1,3,2,4,6,5]
number_list.sort(reverse=True)#降序
print(number_list)#[6, 5, 4, 3, 2, 1]

number_list = [1,3,2,4,6,5]
number_list.reverse()#翻转
print(number_list)#[5, 6, 4, 2, 3, 1]

列表的嵌套（二维列表，三维列表)

a = []
#print(len(a)) #0
a = [[],[],[]]
print(len(a)) #3

zhangsan = ["张三",18,"男"]
lisi = ["李四",20,"男"]
namelist = [zhangsan,lisi]
#print(namelist) #[['张三', 18, '男'], ['李四', 20, '男']]
#print(namelist[0][0]) #第一个列表的，第一个元素
for person in namelist:
    print(person)
    # ['张三', 18, '男']
    # ['李四', 20, '男']
    #拿出每个元素
    for i in person:
        print(i,end = ",")
        print()

统计列表长度

a = ["张三","李四"]
print(len(a))
#2

元素出现的次数

a = ["张三","李四","张三"]
print(a.count("张三"))
#2

元组( )

元组特性

特性1：元素不能修改

特性2：元组只包含一个元素时 需要在元素后面添加逗号

a = (1,)
print(a)

创建元组

#创建元组
tup1 = ("a","b","c")
print(tup1,type(tup1))#('a', 'b', 'c') <class 'tuple'>

元组拆包

a,b,c = (1,2,3)
print(a)#1
print(b)#2
print(c)#3

统计元组出现的次数

a = (1,2,2,2,3)
print(a.count(2))
结果：
3

增加

#增,无法修改（其实是拼接）
# t = (1,2)
# t1 = ("abc","ddd")
# t2 = t + t1
# print(t2)

打印元素的下标

a = (1,2,2,2,3)
print(a.index(3))
结果：
4

遍历元素

a = (1,2,2,2,3)
for i in a:
    print(i)
结果：
1
2
2
2
3

元祖转列表

a = (1,2,2,2,3)
print(type(a))
print(type(list(a)))
print(type(tuple(a)))
结果：
<class 'tuple'>
<class 'list'>
<class 'tuple'>

其它

#删除（删除的是元祖对象,而不是元素）
# t = (1,2)
# del t
# print(t)
#改（不行,里面有可变类型的话，可以修改）
# mylist = ["A","B"]
# t = (10,20,mylist)
# print(t)
# mylist[0] = "c"
# print(t)
#查
# t = (1,2,3,4,5)
# print(t)
# print(t[0])
# print(t[-1]) #访问最后一个元素
# print(t[1:2]) #左闭右开

# t = (1,2,3,4,5,3)
# if 3 in t:
#     print("true")
# else:
#     print("false")

# t = (1,2,3,4,5,3)
# print(t.count(3))

字典{ }

待梳理

#查找，通过键访问
a = {"name":"王建","age":18}
print(a["name"]) #如果没有，则报错
print(a.get("name")) #这个方式比较常用，如果没有返回none
print(a.get("gend","m")) #如果没有值，就返回m

#通过列表创建字典
namelist = ["小王","小白","小张"]
#dic1 = {}.fromkeys(namelist) #默认值为none
dic1 = {}.fromkeys(namelist,"颜值高") #给固定的值
print(dic1) #{'小王': '颜值高', '小白': '颜值高', '小张': '颜值高'}

#增
# a = {"name":"王建","age":18}
# a["id"] = 10
# print(a)
#删
a = {"name":"王建","age":18}
# # del a["name"] #删除元素
# del a #直接删除字典
#a.clear() #清除元素
name = a.pop("name") #弹出name的值，但是显示时，键和值都不显示
gen = a.pop("gen","不存在改键") #删除一个不存在的键，会报错，可以返回指定的默认值
gent = a.popitem() #删除最后一个键值对，返回的是元祖类型
print(gen,a) #王建 {'age': 18}

定义一个字典

qfly={"name": "秋风落叶","age":18}
print(type(qfly))
结果：
<class 'dict'>

获取所有key

qfly={"name": "秋风落叶","age":18}
print(qfly.keys())
结果：
dict_keys(['name', 'age'])

获取所欲值

qfly={"name": "秋风落叶","age":18}
print(qfly.values())
结果：
dict_values(['秋风落叶', 18])

获取所有key value 元组列表

qfly={"name": "秋风落叶","age":18}
print(qfly.items())
结果：
dict_items([('name', '秋风落叶'), ('age', 18)])

遍历打印字典

qfly={"name": "秋风落叶","age":18}
for k ,v in qfly.items():#先输入成元祖
    print(k,v)
结果：
name 秋风落叶
age 18

集合

#定义集合,无序的,只能存放可变元素,不能放字典、列表类型数据
# a = set() #空集合
# #a = {1,2,3}
# print(a,type(a)) #{1, 2, 3} <class 'set'>
#去重,自动去重
# a = {1,2,3,3,4}
# print(a)
#增
# a = {1,2,3}
# # print(a)
# # a.add(4) #方式1
# #a.update("ac") #方式2  {'c', 1, 2, 3, 'a'}
# b = ["a","b"]
# a.update(b)
# print(a) #{1, 2, 3, 'b', 'a'}

#删
# clear remove（只有一个参数,不支持，不可以设置默认值） pop(随机弹出一个)
#discard ,对比remove，如果不存在不报错。
#改，变相删除，先删除后增
a = {1,2,3}
a.remove(1)
a.add(4)
print(a) #{2, 3, 4}
#查,遍历 for 循环
a = {"a","b","c",}
res = "a" in a #not in
print(res) #True

数据类型对比

字符串高级操作

字符串长度计算

#字符串的长度 元素的个数
s4 = "hello word!"
print(len(s4)) #11个元素，包括空格
s5 = "王"
print(len(s5)) #1  长度是1个字符

判断字符串是否存在

#判断字符串是否存在
s1 = "wang  w  j  王"
print("w" in s1) #True  判断w是否在s1中。
print("wa" in s1) #True
print("wangj" in s1) #False
print("h" in s1) #False

字符串的内置方法

待梳理

# 字符串内置函数，只要是内置方法就可以用点。
s1 = "wang"
s2 = "WANG"
s3 = "123"
s4 = "   456 789 "
s5 = "   456789 "
s1Upper = s1.upper()  # 字符转大写 WANG
print(f"这是转大写:{s1Upper}")
print(f"这是转大写,写法2:{s1.upper()}")  # 写法2，不用设置变量，直接输出
print(f"这是转小写:{s2.lower()}")
print(f"判断是否以w开头:{s1.startswith('w')}")  # 判断是否以w开头:True
print(f"判断是否以w结尾:{s1.endswith('w')}")  # 判断是否以w结尾:False
print(f"判断是否是纯数字字符串:{s1.isdigit()}")  # 判断是否是纯数字字符串:False
print(f"判断是否是纯数字字符串:{s3.isdigit()}")  # 判断是否是纯数字字符串:True
print(f"去除两边的空格及换行符:{s4.split()}") #去除两边的空格及换行符:['456', '789']
print(f"去除两边的空格及换行符:{s5.split()}") #去除两边的空格及换行符:['456789']

str = "wangjian word"
res = str.capitalize() #首字母大写
res = str.title() #每个单词首字母大写
res = str.istitle() #判断每个单词首字母是否大写
res = str.lower() #字母变小写
res = str.swapcase() #字母变大写

# split分隔符,把字符串拆分为列表
s1 = "豫 北京 重庆 哈尔滨"
ret = s1.split(" ")  # 以空格为分隔符
print(ret)  # ['豫', '北京', '重庆', '哈尔滨']
print(f"一共有{len(ret)}城市！")  # 一共有4城市！
#join拼接符
s2 = "豫 北京 重庆 哈尔滨"
ret = s2.split(" ")  # 先用空格为分隔符，把字符串分开
pingJie="-".join(ret) #在用join以-进行拼接
print(pingJie) #豫-北京-重庆-哈尔滨

# 查找位置
s1 = "豫 北京 重庆 哈尔滨"
st = s1.find("北京")  # find查找北京在哪个位置
st2 = s1.find("ha")
#st3 = s1.index("f")  # index用法和find一样，区别是如果没有找到会报错
print(st)  # 打印具体位置索引 结果为 2
print(st2)  # 找不到为报-1  结果为-1
#print(st3)  # substring not found

# 计数
s1 = "豫 北京 北京 重庆 哈尔滨"
con = s1.count("北京") #查找北京出现了几次
print(con) #2次


统计与查找
str = "wangjian word 王建"
#res = str.count("w") #统计w出现的次数
#res = str.find("o") # 查找o下标在哪个位置,只匹配第一次匹配的位置
#res = str.find("o",4) #从第4个位置开启匹配
res = str.find("o",1-4) #表示在1-4的位置匹配[1,4)  找不到返回-1
print(res)



#res = "  "
#res = "\t \r\n"
#判断字符串中是否只包括空白
#print(res.isspace())
#res = "abc"
res = "8"
#判断字符串至少有一个字符串并且所有字符都是字母返回true
#print(res.isalpha())
#判断是不是数字加字符，全字符或者全数字true
print(res.isalnum())
#检测字符串是否是以数字组成，必须是纯数字
print(res.isalnum())
#检测字符串只包含数字则返回真
print(res.isdigit())
#检测字符串中只包括数字字符，返回真
print(res.isnumeric())

切片

string = "hello world"
print(string[1:])
结果：
ello world

string = "hello world"
print(string[1:5])
结果：
ello

判断开头和结尾

判断开头和结尾
str = "wangjian"
#res = str.startswith("w") #判断是否是w开头
# res = str.startswith("g",3) #判断第3个位置是否是w结束的
# res = str.startswith("g",3,5) #判断第3-5的位置是否是g结束的
#res = str.endswith("w") #判断是否是w结尾
res = str.endswith("w",-4,-1) #判断-4-1是否是w结尾
print(res)

替换replace

#replace 替换字符串（第三个参数选择替换的次数）
#str = "王 建 中 国 王"
#res = str.replace(" ","/") #把空格替换成/
#res = str.replace("王","李",1) #把王变成李，只替换第一个
#strip 默认去掉首尾两边的空白符
#lstrip 去掉左侧的空白符
#rsrip 去掉右侧的空白符
str = "\r wang \t \n"
print(str)
res = str.strip()
print(res)

#替换
s2 = "豫 北京 北京 重庆 哈尔滨"
new = s2.replace("豫","河南") #把豫变为河南
new1 = s2.replace("北京","京",1) #只替换一次，把查到的第一个替换掉即可
print(new) #河南 北京 北京 重庆 哈尔滨
print(new1)#豫 京 北京 重庆 哈尔滨

长度填充

#字符串长度
str = "wang"
res = len(str)
print(res)
#center填充字符串，默认填充空格
res1 = str.center(10,"_")
print(res1)

编码与解码

#max 返回字符串中编码最大的字母
#mix 返回字符串中编码最小的字母
str = "王建中国"
print(max(str))
print(min(str))

#unicode内置编码打印ord
print("'王'的编码",ord("王"))
#chr 给对于的编码，打印字符
print(chr(890))

str = "王建中国"
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print("utf-8编码:",str_utf8,type(str_utf8))
print("gbk编码:",str_gbk,type(str_gbk))

print("utf-8解码：",str_utf8.decode('UTF-8','strict'))
print("gbk解码:",str_gbk.decode('GBK','strict'))

流程控制

if_else

案例1: 双分支语句

# 案例1 双分支语句
age = int(input("请输入你的年龄:"))
if age >= 18:
    print("可以看成人电影")
    print("腾讯区")
    print("优酷区")
    print("爱奇艺区")
else:
    print("只能看青少年电影")
    print("天线宝宝")
print("欢迎收看")

案例2 :多路分支语句

# 案例2 多路分支
# BMI <18.5 偏瘦 ， 18.5-24.0  正常 ，24.0-28 超重，大于28 肥胖，
height = float(input("请输入你的身高[米]:"))
weight = float(input("请输入你的体重[公斤]:"))
BMI = weight / height ** 2
if BMI < 18.5:
    print("您的体重偏瘦")
elif 18.5 < BMI < 24.0:
    print("您的体重正常，你很棒！")
elif 24 < BMI < 28:
    print("您的体重超重，请注意减肥")
else:
    print("您的体重是属于肥胖，请注意减肥")
print(BMI)

案例3：分支嵌套

# 案例3：分支嵌套
pid = input("请输入您的身份证号:")
# 先判断身份证号是不是18位
if len(pid) == 18:
    print(f"打印个人基本信息,您的身份证号是:{pid}")
    # 打印性别，身份证号倒数第二位如果是偶数 则是女的，否则是男的
    num = int(pid[-2])  # 取倒数第二个
    if num % 2 == 0:  # 判断奇偶数
        print("此身份证是女的")
    else:
        print("此身份证是男的")
    # 打印籍贯
    iguana = pid[:6]  # 取出前6个字符
    if iguana == "412829":
        print("籍贯是：河南驻马店")
    else:
        print("其他的籍贯，以后慢慢在查询吧")
else:
    print("身份证位数输入有误，请重新输入！")

while

打印 5 次 hello python

#打印hello python
#先定义重复次数计算器
i = 1
#使用 while 判断条件
while i <= 5:
    #需要执行的代码
    print("hell python")
    #处理计数器 i
    i = i + 1
print("循环结束后的i = %d" % i)
#hell python
#hell python
#hell python
#hell python
#hell python

死循环 不要乱用

while True:
    print("hello word")

计算 1-100 的和

#计算 1-100之间的所有数字的和
#0.定义最终结果的变量
result = 0
#1.定义一个整数的变量记录循环的次数
i = 0
#2.开始循环
while i  <= 100:
    #每一次循环，都让result 这个变量和 i 这个计数器相加
    result += i
    #处理计数器
    i += 1
print("0-100之间的数字和为 = %d" % result)
#0-100之间的数字和为 = 5050

计算 1-100 偶数和

#计算 1-100之间的所有偶数的和
#0.定义最终结果的变量
result = 0
#1.定义一个整数的变量记录循环的次数
i = 0
#2.开始循环
while i  <= 100:
    #判断偶数
    if i % 2 == 0:
        # 每一次循环，都让result 这个变量和 i 这个计数器相加
        result += i
    #处理计数器
    i += 1
print("0-100之间的数字偶数和为 = %d" % result)
#0-100之间的数字偶数和为 = 2550

打印1-10

#方式1
n = 0
while n < 10:
    n += 1
    print(n)

#方式2
n = 1
while n <= 10:
    print(n)
    n += 1
#打印10-1
n = 10
while n >= 1:
    print(n)
    n -= 1

for

for 遍历基于容器

#遍历字符串
s = "abcd"
for i in s:
    print(i)
#遍历列表
s = [1,2,3,4,5]
for i in s:
    print(i)

range循环打印

range(开始位置，结束位置，步长)

#range循环 打印1-2
for i in range(1,3):
    print(i)
结果：
1
2

range倒着打印

#倒着打印
for i in range(5,1,-1):
    print(i)
5
4
3
2

打印奇偶数

#打印偶数
for i in range(2,10,2):
    print(i)
结果：
2
4
6
8

#打印奇数
for i in range(1,10,2):
    print(i)
结果：
1
3
5
7
9

拼接打印

s = ''
for i in range(5):
    s+=str(i)
print(s)  #01234

随机验证码案例

#随机生成一个5位数的验证码
# 随机数
import random
# 随机打印出26个字母以及数字
import string
s = ''
for i in range(5):  # 循环打印5次
    # choice方法会在序列里面选择一个打印出来
    # char = random.choice("0123456789abcdef") #手动敲字符太累
    # print(string.ascii_lowercase)  # 打印abcdefghijklmnopqrstuvwxyz
    # print(string.ascii_uppercase)  # 打印ABCDEFGHIJKLMNOPQRSTUVWXYZ
    # print(string.digits)  # 随机打印0123456789
    # 开始拼接
    char = string.ascii_lowercase + string.ascii_uppercase + string.digits
    # print(char)  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
    # 在随机取出来一个
    randomChar = random.choice(char)
    # print(randomChar)
    s += randomChar
print(s)

break

案例 1

#break 退出整个循环
for i in range(1,11):
    if i == 3:
        break
    print(i)
结果：
1
2

打印圆的面积

# 打印半径为1m-100m的圆的面积
for r in range(1, 101):
    # 计算圆的面积
    area = 3.1415962 * r ** 2
    print(f"半径为{r}的圆的面积是:{area}")

#升级版 #在其中找到第一个面积大于1000的半径值
for r in range(1, 101):
    # 计算圆的面积
    area = 3.1415962 * r ** 2
    # 在其中找到第一个面积大于1000的半径值
    if area > 1000:
        print(f"半径为{r}的圆的面积是:{area}")
        break

continue

#退出当前循环，进入下一个循环
for i in range(1, 5):
    if i == 3:
        continue
    print(i)  # 1  2  4

案例

摇车牌案例

完整版案例

import random  # 随机数
import string  # 随机打印出26个字母以及数字
"""
需求:
1.允许用户最多选3次
2.每次放出5个车牌供用户选择
3.车牌是大写字母和数字组合
4.车牌是6个字符组合
"""
count = 0
while count < 3:  # 代表可以选3次
    car_nums = []
    for i in range(5):  # 循环5次，生成5组车牌
        # 生成的车牌放在一个列表中
        # 车牌的第一个字母 必须大写 string.ascii_uppercase代表生成大写字母  random.choice代表随机在里面找一个
        n1 = random.choice(string.ascii_uppercase)
        # 车牌的后面5个字母 string.digits代表生成0-9的数字，然后和字母拼接，在用随机数取出5个，最后用join转字符
        n2 = "".join(random.sample(string.ascii_uppercase + string.digits, 5))
        car_num = f"皖{n1}·{n2}"
        car_nums.append(car_num)  # 把生成的车牌，累加起来存到一个列表中
        print(i + 1, car_num)  # 打印序号 及车牌
    if count == 0:
        print("温馨提示:当前是第一次选择")
    elif count == 1:
        print("温馨提示:当前是第二次选择")
    elif count == 2:
        print("温馨提示:当前是第三次选择")
    ch = input("请输入你喜欢的车牌:").strip()  # strip 代表去除输入两边多余的空格 回车
    if ch in car_nums:  # 代表选择的车牌在列表中
        print(f"恭喜你选择了新车牌号:{ch}")
        exit("祝您好运!!!")
    else:
        if count == 2:
            print("你选择的车牌不正确，且三次选择已用完，自动退出程序")
            break
        print("你选择的车牌不正确请重新输入")
    count += 1

打印小星星✨✨✨

#第一行 1 个
row = 1
while row <= 5: #打印 5 行
    print("*" * row)
    row += 1
*
**
***
****
*****

打印 99 乘法表

#定义起始行
row = 1
#z最大打印 9 行
while row <=9:
    #定义起始列
    col = 1
    #最大打印 col 列
    while col <=row:
        print("%d * %d = %d" %(col,row,row*col),end="\t")
        #列+1
        col += 1
    #一行打印完成的换行
    print()
    #行+1
    row += 1

1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81

常用模块

random随机数

可以产生指定范围内的随机数、字符串等 random是获取0-1之间的数

import random
s1 = random.choice("abcd") #在其中随机输出一个
s2 = "abcded"
s3 = random.sample(s2,3) #在字符串中，随机显示3个
s4 = random.randint(1,100) #打印1-100的一个随机数
s5 = (round(random.random()*100)) #随机获取100以内的随机数
print(f"s1={s1}")
print(f"s2={s2}")
print(f"s3={s3}")
print(f"s4={s4}")
print(f"s5={s5}")


结果：
s1=b
s2=abcded
s3=['d', 'e', 'd']
s4=68
s5=68

文件操作

案例1：

with open("hello.txt", mode="w", encoding="utf-8") as f:
    f.write("a")
    f.write("b")

字符操作

• r 以只读的方式打开文件，也是默认模式
• w 打开一个文件用于写入，没有则创建
• a 打开一个文件用于追加内容
• r+ 打开一个文件用于读写，文件指针将会放在文件的开头
• w+ 打开一个文件用于读写，没有则创建
• a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模
  式。如果该文件不存在，创建新文件用于读写

写入操作

创建一个文件,用于读写，py3默认都是utf-8，不用加字符集

f = open("秋风落叶.txt","w+") #这样一个秋风落叶.txt文件就创建好了
py2中 需要指定字符集，不然容易乱码
f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")

往文件中添加内容，单行操作

f = open("秋风落叶.txt","w+")
f.write("今天天气怎么？")
f.close() #关闭文件

多行写入

#写入多行
#f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")
#f.write("哈哈\n你好\n世界\n") #方式1，通过换行符
# cont = ["王建\n","中国\n"]
# f.writelines(cont)  #方式2:
# f.close()

#不用每次加入\n 推荐此方式
f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")
cont = ["王建","中国"]
f.write("\n".join(cont)) #方式3
f.close()

访问模式 a 追加文件 ,也可用a+

f = open("0226.txt","a+")
print(f.read())
f.write("\n北京")
f.write("\n上海")
f.close()

强制把缓冲的数据写入到硬盘

f = open("0226.txt", "w+")
f.write("hello\n")
print("返回光标当前位置", f.tell())
f.write("hello\n")
print("返回光标当前位置", f.tell())
f.seek(7)
f.write("----")
f.flush()  # 强制把缓冲区的数据写入到硬盘，在执行命令行时，最后可以添加这个

跳到某个位置继续写入，把后面的替换掉了，不是追加，是覆盖

f = open("0226.txt", "w+")
f.write("hello\n")
f.write("hello\n")
f.seek(3)  # 跳到第3个字符位置继续写
f.write("--")
结果：
hel--
hello

路径忽略

# f = open(r"D:\pythondemo\test.txt","w") #r 忽略所有的\线，直接访问路径
# f.write("wangjian")
# f.close()

读取操作

#2.文件的读read 把数据从文件中取到程序中
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# #date = f.read() #要有一个返回接受
# #date = f.read(2) #只读前两个字符
# date = f.read((4)) #读前4个，但是前两个已经读出来，会只显示后两个字符
# print(date)
# f.close()

#读取一行
f = open("hell")  # 如果不指定路径的话，默认是当前项目路径下
print(f.read())  # 默认是读取所有
print(f.readline())  # 默认读取第一行
f.close()

#读取每行
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# while True:
#     content = f.readline()
#     if content:
#         print(content,end="")
#     else:
#         break
# f.close()

#读取多行，一次性读取全部文件为列表，每行一个字符串元素
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# content = f.readlines()
# #print(content)
# i = 1
# for date in content:
#     print(date,end="")
#     i+=1
# f.close()
#方式2
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# content = f.readlines()
# for i,date in enumerate(content):
#     print(date,end="")
# f.close()

返回指针当前所在的位置tell，字节数,我在哪

#返回指针当前所在的位置tell，字节数,我在哪
f = open("0226.txt", "w+")
f.write("hello\n")
print("返回光标当前位置",f.tell())
f.write("hello\n")
print("返回光标当前位置",f.tell())
结果：
返回光标当前位置 6
返回光标当前位置 12

seek 定位文件读取的指针所在位置(字节)，我要到哪里去

#seek 定位文件读取的指针所在位置(字节)，我要到哪里去
#seek (offset [,whence])
#offset - 开始的偏移量，也就是代表需要移动偏移的字节数
#were 可选，默认值为0
f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
con = f.read(2)
print(con)
f.seek(4) #指定的是字节数
print("当前指针所在位置:",f.tell())
f.close()

综合案例1

文件内容如下：

1. 张三 安徽 173 100 1245
2. 李四 北京 170 90 1246
3. 王五 上海 160 80 1255
4. 赵六 河南 150 70 1255
4. 胡七 安徽 140 60 1345

"""
需求：
找到学生 升高大于160 ，且体重大于80的学生
"""
f = open("学生信息")
for line in f:  # 每循环一次 ，打印一行
    line = line.split() #把每行字符串分成了一个列表
    height = int(line[3]) #取列表中第3个元素,因为是字符串，需要转换为int进行比较
    weight = int(line[4])
    if height >= 170 and weight >=80:
        print(line)
    #print(line,end="")#去除回车换行符
    #print(f.readlines()) #每行数据，变为一个列表中的元素 最终变为一个大列表
结果如下：
['1.', '张三', '安徽', '173', '100', '1245']
['2.', '李四', '北京', '170', '90', '1246']

二进制操作

二进制操作（图片、音乐、视频等）

• rb 二进制只读模式
• wb 二进制创建模式，若文件已存在，则覆盖旧文件
• ab 二进制追加模式，新数据会写到文件末尾

这样你读出来的数据就是bytes字节类型的，当然写进去也必须是二进制的。

写入操作

以二机制方式写入文件

f = open("秋风落叶", "wb")  # 创建了一个名为秋风落叶的文件，以wb也就是二进制的方式写入
s = "王"  # 定义一个字符串，表示要写入的内容
f.write(s.encode("utf-8"))  # 写入的内容的字符编码,此处必须编码
f.write("测试")  # 这样写，只能报错，字符串是写不进去的。TypeError: a bytes-like object is required, not 'str'

#二进制操作（图片、音乐、视频等）
#rb:read binary  wb:write binary
#此功能可以看做是复制一个图片
#读取
fin = open("wallhaven-z8jl7w.jpg",mode="rb" ) #mode="rb" 默认可以不写
#写入
fout = open("wallhaven_bak.jpg",mode="wb")

while True:
    date = fin.read(100) #缓冲区 一次读100字节
    if date:  #不为空
   #if date != b"": 也是不为空，写法2 
        fout.write(date) #读完就写
    else:
        break

fin.close()
fout.close()

read10 读的是啥

#读取
fin = open("wallhaven-z8jl7w.jpg",mode="rb" ) #mode="rb" 默认可以不写
#写入
fout = open("wallhaven_bak.jpg",mode="wb")
date = fin.read(10)
print(date,type(date))
#以b开通表示bytes（字节）方式读取的字符串，是以十六进制表示的内容
#b'\xff\xd8\xff\xe1\x06zExif' <class 'bytes'>

文件写入过程

#文件写入过程
#数据-缓冲区-硬盘
f = open("w.txt",mode="w+",encoding="utf-8")
f.write("王建中国")
while True:
    pass
f.close()
#以上程序执行后，会创建w.txt文件，但是数据没写入，其实执行了，只是在内存用，还没写入硬盘中
#只有执行了close后，才会写入文件

#缓冲区清空的时间节点
#当文件关闭的时候，自动清空
#当整个程序运行结束的时候
#当缓冲区写满的时候
#手动清空缓冲区
f = open("w.txt",mode="w+",encoding="utf-8")
f.write("王建中国")
f.flush() #手动清除缓存，数据写入到文件
while True:
    pass
f.close()

截断

#截断
# f = open("w.txt",mode="w+",encoding="utf-8")
# for i in range(5):
#     f.write("王建中国"+str(i)+"\n") #15个字符,一个汉字3个字符，换号2个
# f.close()
# f.close()

f = open("w.txt",mode="r+",encoding="utf-8")
f.seek(24) #定位到24个字符
f.truncate() #删除24字符之后的数据
f.close()

#方式2
f.truncate(8) #直接删除8之后的数据
f.seek(0)#定位在头部
print(f.read())

文件对象是个可迭代对象

#
f = open("w.txt","r+",encoding="gbk")
print("文件名称",f.name)
print(f.mode) #文件打开的模式
print(f.writable())#文件可写 true
print(f.readable()) #文件可读

读取操作

以二进制方式读取图片

fin = open("截屏2024-02-25 21.37.19.png",mode="rb")
for line in fin:
    print(line)
结果如下：
b'#\xa4m\xcc\x1d\xcf\'\xbf\x9f\xc2=x\xd6\xa8\xd6&\x14\x
b'J\xf1\xbe\'\x1e\x87\x11:G\xf5\x1afLe\xaeB\x02\xe5\x05
.............省略........

文件修改

f = open("修改文件测试.txt","r+")#abcdefg
#需求把cd改为123
#步骤1，先把数据读取到内存中
date = f.read()#全部加载到内容
print(date)#abcdefg
#修改替换
new_data = date.replace("cd","123")
print(new_data)#ab123efg,已经写入到了内存中
#清空硬盘中的原始数据
f.seek(0) #先把光标跳转到首位
f.truncate()#截断文件，从光标之后，都进行删除，此时执行后，去查看硬盘文件为空
#把内存中的数据重新写入到硬盘
f.write(new_data)
f.close()

全局搜索替换文本脚本

# 全局搜索替换文本
import sys

old_str = sys.argv[1]  # 输入的第一个参数 旧字符串
new_str = sys.argv[2]  # 输入的第二个参数 新字符串
fileName = sys.argv[3]  # 输入的第三个参数 需要操作的文件名字
# 步骤1 打开需要操作的文件
f = open(fileName, "r+")
data = f.read()  # 把文件内容全部读取到内存中
# 步骤2 计数 以及替换文本
old_str_count = data.count(old_str)  # 查找旧字符在文件中出现了多少次
new_data = data.replace(old_str, new_str)
# 步骤3 清除磁盘上的旧的文件
f.seek(0)
f.truncate()
# 步骤3 保存内存中的新数据到硬盘上
f.write(new_data)
f.close()
if old_str_count == 0:
    print(f"当前文件中没有你要查询的文本:'{old_str}',请重新执行！")
else:
    print(f"成功把'{old_str}'替换为'{new_str}'，共修改{old_str_count}处")

脚本使用教程

[root@wj ~]# more 1.txt 
中国 安徽 包河区 安徽
[root@wj ~]# python 1.py 安徽 合肥 1.txt
成功把'安徽'替换为'合肥'，共修改2处

用户登录认证程序

"""
需求
1、要求用户输入账号密码进行登陆
2、用户账号信息保存在文件内
3、用户密码输入错误3次后锁定用户，下次在登陆，检测到是锁定的用户，则不允许登陆，提示账号已被锁定

账号信息，第一列是 用户名  第二列是密码  第三列是账号状态1是启用 0是锁定
zhangsan,123,1
lisi,456,1
wangwu,789,1
"""
# 把账号数据保存到内存中，方便调用 存为字典形式
accounts = {}
f = open("user.txt", "r")
for line in f:  # 读取文件中的每一行
    line = line.strip().split(",")
    # print(line)# 以逗号为分割符,此时是一个3列表 ['zhangsan', '123', '1'] ['lisi', '456', '1'] ['wangwu', '789', '1']
    # print(line[0]) #每个列表的第一个元素是 zhangsan  lisi wangwu
    # 存为字典形式 {'zhangsan': ['zhangsan', '123', '1'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
    accounts[line[0]] = line  # 拿到列表line[0]的第一个元素当作key {'zhangsan': ['zhangsan', '123', '1']}
    # print(line)#此时的line 就是字典中的值了
# 最终的字典形式：{'zhangsan': ['zhangsan', '123', '1'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
print(accounts)
while True:  # 用户名可以输入多次
    user = input("请输入用户名:").strip()
    if user not in accounts:
        print(f"您输入的账号【{user}】未注册,请输入注册过的用户名")
        # 如果用户名不存在就，退出当前循环，重新输入用户名，就不用输入密码了，continue必须和循环一起用
        continue
    if accounts[user][2] == "0": #代表此账号已锁定
        print(f"您输入的账号【{user}】是被锁定的账号,请联系管理员解锁,或者是请输入其它账号进行登录")
        continue
    count = 0
    while count < 3:  # 密码只能输入三次
        passwd = input("请输入密码:").strip()
        if passwd == accounts[user][1]:
            print(f"系统登陆成功,您输入的用户名是:{user}")
            exit("登录成功")
        else:
            print(f"密码输入错误,请重新输入")
        count += 1
        if count == 3:
            print(f"当前的用户名{user}密码输入达到了3次,账号已被锁定")
            # 1.先修改内存中的数据，把用户账号的状态1改为0
            accounts[user][2] = "0"
            # 此时内存中，用户的状态已修改 {'zhangsan': ['zhangsan', '123', '0'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
            # print(accounts)
            # 2.在把内存中的数据，存到文件中,并保留原来格式
            f2 = open("user.txt", "w")
            # print(accounts.items())#dict_items([('zhangsan', ['zhangsan', '123', '0']), ('lisi', ['lisi', '456', '1']), ('wangwu', ['wangwu', '789', '1'])])
            for user, val in accounts.items():  # user代表key  val代表值
                line = ",".join(val) + "\n"  # 在把列表转为字符
                # print(line)
                f2.write(line)  # 写入到文件
            f2.close()

        # print(count)

函数

定义函数及调用

#定义函数
def hanshu():
    print("-"*20)
    print("人生苦短，我学python")
    print("-" * 20)
#函数调用
hanshu()

带参数的函数

#带参数的函数
def addnum(a,b): #形参
    c = a + b
    print(c)
addnum(10,22) #实参

#案例2
import datetime
time = datetime.datetime.now().strftime("%Y-%m-%d %X")
def my_log(msg):  # 形参
    with open("my_log.log", mode="a", encoding="utf-8") as f:
        f.write(time)
        f.write(",")
        f.write(msg)
        f.write("\n")
        f.close()

print("开机中....")
my_log("服务器开机启动啦...")  # 实参，函数在调用时，参数必须要有值，不然会报错
print("nginx启动中...")
my_log("nginx启动啦...")
print("tomcat启动中...")
my_log("tomcat启动啦...")

结果：文件中内容
2024-03-07 16:15:18,服务器开机启动啦...
2024-03-07 16:15:18,nginx启动啦...
2024-03-07 16:15:18,tomcat启动啦...

带返回值的函数

#写法1 每次返回一个值
def func(fuHao, a, b):  # 有3个参数
    if fuHao == '+':
        return a + b
    elif fuHao == '-':
        return a - b
    elif fuHao == '*':
        return a * b
    elif fuHao == '/':
        return a / b
ret = func("+",5,6)
print(ret)

#写法2
def func(a, b): 
    return a + b, a - b, a * b, a / b #每次返回多个值，结果是一个元组

ret = func(5, 6)
print(ret)#(11, -1, 30, 0.8333333333333334)



#返回一个字典
def func(a, b): 
    return {"jia": a + b, "jian": a - b, "cheng": a * b, "chu": a / b}#返回一个字典类型
#jia, jian, cheng, chu = func(5, 6)
nu = func(5,6)
print(nu)#{'jia': 11, 'jian': -1, 'cheng': 30, 'chu': 0.8333333333333334}


def jianfa(a,b):
    if a<b:
        return b-a
    else:
        return a-b
print(jianfa(20,30))

return 不写返回值

#这是写了返回值
def fun():
    print("你好啊")
    #return
    print("我叫赛利亚")
    return 123
ret = fun()
print(ret)
结果：
你好啊
我叫赛利亚
12

#不写返回值
def fun():
    print("你好啊")
    return #默认返回是none ,作用是终止一个函数的运行，不给外界返回任何数据
    print("我叫赛利亚")
    return 123
ret = fun()
print(ret)
结果：
你好啊
None

不写return

def fun():
    print("你好啊")
    print("我叫赛利亚")
    #这里不写retrun 默认加上结果none
ret = fun()
print(ret)
结果：
你好啊
我叫赛利亚
None

打印任意字符的分割线函数

#打印任意字符的分割线函数
def print_line(char):
    print(char * 30)
print_line('*')

打印任意字符重复的分割线

#打印任意字符重复的分割线
def print_line(char,number):
    print(char * number)
print_line("=",10)

打印5行任意字符重复的分割线

#先定义打印的内容
def print_line(char,num):
    print(char * num)
#在定义打印的行数
def print_row(char,num):
    row = 0
    while row < 5:
        print_line(char,num)
        row += 1
print_row("=",10)

结果：
==========
==========
==========
==========
==========

解包拆包

#每次返回多个值，结果是一个元组，在把元组拆解成单个
def func(a, b):  # 有3个参数
    return a + b, a - b, a * b, a / b

#a = func(5,6)
#jia ,jian,cheng,chu = a
jia ,jian,cheng,chu = func(5,6)#这样写一步到位
print(jia)
print(jian)
print(cheng)
print(chu)
#结果
11
-1
30
0.8333333333333334

默认参数

def sg(name,age,addr="安徽"):
    print(name,age,addr)
sg("张三",18)
sg("李四",30,"北京")
#结果
张三 18 安徽
李四 30 北京

实参指定形参

def login(user,passwd):
    print(user,passwd)
login(user="zhangsan",passwd="1234")#实参指定形参
#结果
zhangsan 1234

动态传参

#动态位置传参
在形参上，可以用*来动态接受所有的位置参数
可以使用**来动态接受所有的关键字参数
"""
# def chi(*food):#*表示动态接受位置参数，参数名是food
#     print(food)#接受到的是元组()
# chi("小龙虾","螺狮粉")#('小龙虾', '螺狮粉')

#动态关键字传参1
def chi(*food,pei="林志玲"):
    print(pei,"陪你吃",food)#接受到的是元组()
chi("小龙虾","螺狮粉",pei="小团团")#小团团 陪你吃 ('小龙虾', '螺狮粉')

#动态关键字传参2
def chi(*food, **kan):  # *表示动态接受位置参数，参数名是food,**动态关键字参数
    print(kan, "陪你吃", food)  # food接受到的是元组()，kan接受到的是字典


chi("小龙虾", "螺狮粉", kan="小团团")  # {'kan': '小团团'} 陪你吃 ('小龙虾', '螺狮粉')

#注意
如果混搭，注意书写顺序，位置参数>*args>默认值参数>**args

#动态实参传参
ldef func(*args):
    print(args)


lst = ["香蕉", "皮蛋", "葡萄"]
func(lst)  # (['香蕉', '皮蛋', '葡萄'],) 元组里面是个列表
# 在实参可以用*号打散一个列表、元组 集合 字符串，成位置参数进行传递
func(*lst)  # ('香蕉', '皮蛋', '葡萄')  是一个元组


def fn(it):
    print(it)


fn(lst)  # ['香蕉', '皮蛋', '葡萄']
fn(tuple(lst))  # ('香蕉', '皮蛋', '葡萄') 直接转为元组

函数调用嵌套

def add2num(a,b):
    return a+b
def add3num(a,b,c):
    return add2num(add2num(a,b),c)
print(add3num(10,20,30))

函数注释及说明

def calc(a: int, b: int) -> int:
    """
    a:int 表示a的类型是什么
    ->表示 函数的返回值是什么类型
    j计算a+b的和
    :param a: 第一个数的值
    :param b: 第2个数的值
    :return: 返回a+b
    """
    return a + b


ret = calc(1, 2)

函数本质

函数也可以赋值
def fun():
    global a  
    a = 20  


fun()
an = fun
print(id(fun))  # 4309466800
print(id(an))  # 4309466800

装饰器

本质就是在不改变原有函数的基础上给函数增加新的功能，可以在开始之前也可以在之后。

案例1

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game): #wai_gua： 装饰器的名字  game：被装饰的函数
    #inner：被返回的函数，用来替代原函数
    def inner(*args,**kwargs):#*args,**kwargs，给原函数同样的参数配置
        print("----开启log外挂----")
        ret = game(*args,**kwargs) #game（） 运行原函数，ret是原函数的返回值
        print("----lol外挂关闭----")
        return ret #把原函数运行的结果反馈给调用方，在调用方看来，得到的结果依然是原函数的结果
    return inner #用来替代原函数


@wai_gua  # 使用装饰器 play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)
    return "打的好,返回一个妹子"

def play_dnf():
    print("我要打dnf")


ret = play_lol("admin","123456")
print(ret)
play_dnf()

"""
----开启log外挂----
我要打lol admin 123456
----lol外挂关闭----
打的好,返回一个妹子
我要打dnf
"""

案例2

flag = False  # 默认没有登录


def log():
    global flag
    while 1:
        usernmae = input("请输入用户名：")
        passwd = input("请输入密码：")
        if usernmae == "admin" and passwd == "123456":

            print("登录成功")
            flag = True
            break
        else:
            print("账号密码错误，请重新登录")


def warpper(fn):
    def inner(*args, **kwargs):
        if not flag:
            log()
        ret = fn(*args, **kwargs)
        return ret

    return inner

@warpper
def add():
    print("我要新增博客")

@warpper
def upd():
    print("我要修改博客")


add()
upd()

"""
请输入用户名：admin
请输入密码：123456
登录成功
我要新增博客
我要修改博客
"""

万能版本没有返回值的

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner(*args,**kwargs):#为了适用各种参数的适用
        print("----开启log外挂----")
        game(*args,**kwargs)
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)


def play_dnf():
    print("我要打dnf")


play_lol("admin","123456")
play_dnf()

初始版本

# 装饰器
def wrapper(fn):  # fn是你要装饰的函数，你要给谁增加新功能
    def inner(*args, **kwargs):  # inner 可以接受所有的参数
        print("请先登陆")
        ret = fn(*args, **kwargs)  # 在运行你要装饰的那个函数
        return ret

    return inner  # 这是最关键的一句话


def add_blog():
    print("我想写一个博客")
    """
    如果我想在写博客的前面添加一个登陆验证，但是我又不想动现在已有固定稳定的代码
    在这是添加添加登陆验证的，但是需要改动目前的代码，有风险。
    """


def search_blog():
    print("我想查看博客")


add_blog = wrapper(add_blog)  # 要装饰的函数
# 从这里开始 add_blog变成wrapper里面的inner了
add_blog()

search_blog()

简版写法1

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner():
        print("----开启log外挂----")
        game()
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol():
    print("我要打lol")


def play_dnf():
    print("我要打dnf")


play_lol()
play_dnf()

简版2

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner(username,passwd):
        print("----开启log外挂----")
        game(username,passwd)
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)


def play_dnf():
    print("我要打dnf")


play_lol("admin","123456")
play_dnf()

结果：
----开启log外挂----
我要打lol admin 123456
----lol外挂关闭----
我要打dnf

简版2

# 装饰器
def wrapper(fn):  # fn是你要装饰的函数，你要给谁增加新功能
    def inner():  # inner 可以接受所有的参数
        print("请先登陆")
        fn()  # 再运行你要装饰的那个函数

    return inner  # 这是最关键的一句话


@wrapper  # 这样写就是装饰器，哪里有需要，就加哪里等价于add_blog = wrapper(add_blog)
def add_blog():
    print("我想写一个博客")
    """
    如果我想在写博客的前面添加一个登陆验证，但是我又不想动现在已有固定稳定的代码
    在这是添加添加登陆验证的，但是需要改动目前的代码，有风险。
    """


@wrapper  # 这样写就是装饰器，哪里有需要，就加哪里
def search_blog():
    print("我想查看博客")


# 从这里开始 add_blog变成wrapper里面的inner了
add_blog()

search_blog()

还未归类

#可变参数，定义时作用  打包
def priinfo(name,age,*args):
    print(f"姓名:{name},年龄:{age}")
    print("作品评分:",args)
priinfo("王建",20,"男",8.9,8.7,9.0)
# 姓名:王建,年龄:20
# 作品评分: ('男', 8.9, 8.7, 9.0)

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    print(kwargs)
priinfo("王建",20,身高=1.65,国籍="中国",出生地="驻马店")
# 姓名:王建,年龄:20
# {'身高': 1.65, '国籍': '中国', '出生地': '驻马店'}

#可变参数，调用时作用 解包
def priinfo(name,age,*args):
    print(f"姓名:{name},年龄:{age}")
    print("作品评分:",args)
#rate = [8.9,8.7,9.0]  #列表
#rate = (8.9,8.7,9.0) #元祖
rate = {8.9,8.7,9.0} #集合 默认无序
priinfo("王建",20,*rate)
# 姓名:王建,年龄:20
# 作品评分: (8.9, 8.7, 9.0)

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    print(kwargs)
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# {'身高': 1.65, '国籍': '中国', '出生地': '驻马店'}

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    #print(kwargs)
    for key ,value in kwargs.items():
        print(f"key是:{key}:值是:{value}")
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# key是:身高:值是:1.65
# key是:国籍:值是:中国
# key是:出生地:值是:驻马店


def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    #print(kwargs)
    for key ,value in kwargs.items():
        print(f"{key}:{value}",end="\t")
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# 身高:1.65	国籍:中国	出生地:驻马店	

input输入函数

# input输入 案例1
name = input("请输入你的名字:")
age = input("请输入你的年龄:")
print(f"我的名字是:{name},我的年龄是:{age}")
# input输入 案例2
numStr1 = input("请输入数字1:")
numStr2 = input("请输入数字2:")
print(type(numStr1), type(numStr2))  # <class 'str'> <class 'str'>
num1Int = int(numStr1)
print(type(num1Int))  # <class 'int'>
num2Int = int(numStr2)
print(f"输入的数字之和是：{num1Int + num2Int}")  # 输入的数字之和是：22

print输出函数

#print输出函数,默认是空格当做分隔符
print(100,"w","王")# 100 w 王
print(100,"w","王",sep="-")# 100-w-王 修改为以-作为分隔符
print(100,"w","王",end=";")# 100 w 王; 修改换行符为分号
print(200)#100 w 王;200

根据用户输入的数字，打印相应行数的线条

#根据用户输入的数字，打印相应行数的线条
def priol():
    print("-"*30)
def prinul(num):
    i = 0
    while i<num:
        priol()
        i+=1
numm = input("请输入对应的数字：")
prinul(int(numm))

求平均数

#求3个数的平均数
def he(a,b,c):
    return a+b+c
#print(he(1,2,3))
def ave3n(a,b,c):
    return he(a,b,c)/3.0
result = ave3n(1,2,3)
print(result)

递归运算

#递归的写法
# 1、编写函数体（功能）
# 2、确定结束条件和返回值
# 3、调用函数自身，修改参数


def printNum(n):
    print(n) #执行的运算
    if n == 1: #最终结束的条件
        return #返回的数值
    printNum(n-1) #调用自身函数
printNum(100)

# 求指定位数阶乘 n! = n*(n-1)
#比如求5的阶乘：5*4*3*2*1
#分析：
#f(1) = 1 n<=1
#f(n) = f(n-1) * n n>1
def fac(n):
    if n <=1:
        return 1
    return fac(n-1) * n
print(fac(6))

#斐波那契数列，根据用户指定的项数，计算对应位置的值
#0 1 1 2 3 5 8 13
#f(n) = n n<=1
#f(n) = f(n-1) + f(n-2)

def fb(n):
    if n <=1:
        return n
    return fb(n-1) + fb(n-2)
print(fb(9))

#for写法

def feb(n):
    if n<=1:
        return n
    res = 0 #存和最终的和
    feb0 = 0 #用于存储下一次运算的内容
    feb1 = 1 #用户下一次运算的和
    for i in range(2,n+1):
        print(f"res:{res},feb0:{feb0},feb1:{feb1}")
        res = feb0 + feb1
        feb0 = feb1
        feb1 = res
    return res

print(feb(5))
# res:0,feb0:0,feb1:1
# res:1,feb0:1,feb1:1
# res:2,feb0:1,feb1:2
# res:3,feb0:2,feb1:3
# 5

变量

a = 10


def fun():
    global a  #引用全局变量，只能引用外层
    nonlocal a #引入当前函数外层的局部变量，就是有两层函数，或者多层函数
    a = 20 #此时是修改a的值，不再是创建变量a了
fun()

迭代器

是一个标准，统一了一些数据类型的循环方式.

• 特别省内存（结合生成器来看）
• 任何数据类型就能打印出来
• 只能向前，不能后退
• 一次性的，如果走到头在取，就报错
• 如果一个数据有__iter__，我们称为可迭代对象
• 如果一个数据有__next__，我们称为迭代器

案例1：

it = [11,22,33].__iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())
"""
11
22
33
"""

案例2：

def dtq(date):
    from collections.abc import Iterable  # 可迭代的
    if isinstance(date, Iterable):  # 判断date是否是可迭代的
        it = date.__iter__()
        while 1:  # 不知道要循环多少次
            try:
                print(it.__next__())
            except StopIteration as e:
                # print("执行完成")
                break


dtq("abc")
"""
a
b
c

####################################################
def dtq(date):
    it = date.__iter__()
    while 1: #不知道要循环多少次
        try:
            print(it.__next__())
        except StopIteration as e:
            #print("执行完成")
            break
dtq("123")
"""
1
2
3
"""

复习各种类型

# 列表
lb = [1, 2, 3]
print(lb.__iter__())  # list_iterator
# 元组
yz = (11, 22)
print(yz.__iter__())  # tuple_iterator
# 字符串
zfc = "123"
print(zfc.__iter__())  # str_ascii_iterator
# 集合
jh = {"姓:", "wang"}
print(jh.__iter__())  # set_iterator
# 字典
zd = {"name": "wang"}
print(zd.__iter__())  # dict_keyiterator

生成器

• 在函数中如果包含了yield，通过yield来返回数据的话，这个函数就是生成器函数
• 函数名（）此时不是在运行函数，而是是创建生成器

案例1：

def func():
    print("haha")
    yield 123
    print("helll")
    yield 456


mm = func()  # 创建了一个生成器generator
mm.__next__()  # 才会让生成器开始干活，执行到下一个yield为止
mm.__next__()
"""
haha
helll
"""

案例2：

"""
比如我需要生成9999个数据，普通方式就是直接在内存中一次性生成了
"""
lst = []
for item in range(9999):
    lst.append(item)
print(lst)
"""
改进版本，用一个拿一个 不需要一次性全部生成
"""
def func():
    for i in range(9999):
        yield i
gen = func()#生成器记录步骤和代码
print(gen.__next__())
print(gen.__next__())
"""
0
1
"""

生成器表达式推导式

"""
推导式

"""
# 普通写法
lst = []
for i in range(1, 5):
    s = f"乡村爱情{i}"
    lst.append(s)
print(lst)  # ['乡村爱情1', '乡村爱情2', '乡村爱情3', '乡村爱情4']
# 列表推导式写法 一行搞定
lst = [f"乡村爱情{i}" for i in range(1, 5)]
print(lst)  # ['乡村爱情1', '乡村爱情2', '乡村爱情3', '乡村爱情4']

# 求10以内被2整除的数
inn = [i for i in range(1, 10) if i % 2 == 0]
print(inn)  # [2, 4, 6, 8]

# 找出姓张的同学，并把张 改为王
zz = ["张无忌", "张三丰", "李夏怡", "赵铭"]
su = [name.replace("张", "王") for name in zz if name.startswith("张")]
print(su)  # ['王无忌', '王三丰']

# 字典推导式
lst = [11, 22, 33]
dic = {i: lst[i] for i in range(len(lst))}
print(dic)  # {0: 11, 1: 22, 2: 33}

# 集合
lstt = [11, 22, 33]
dic = {lstt[i] for i in range(len(lstt))}
print(dic)  # {33, 11, 22}

#没有元组推导式

常用函数

时间相关

import time
print("******")
time.sleep(5)#休息5秒
print("------")

#打印当前时间 格式是：2024-02-18 09:38:17
import datetime
print(datetime.datetime.now().strftime("%Y-%m-%d %X")) 

异常

基本异常

n = input("请输入被除数: ")
m = input("请输入除数: ")
if n.isdigit() and m.isdigit(): #是否是0
    if m != "0":
        res = float(n)/float(m)
        print("res:",res)
    else:
        print("除数不能为0")
else:
    print("请输入数字")
print("程序继续运行并正常结束")


#捕获异常
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
    print("res:",res) #如果报错，这句代码不会执行
except:
    print("出错了")
print("程序继续运行并正常结束")

#指定要捕获的异常类型
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
    print("res:",res) #如果报错，这句代码不会执行
except ValueError:
    print("请输入数字") #数字错误
except ZeroDivisionError:
    print("除数不能为0") #除0错误
except BaseException:
    print("出错了") #所有错误类型
    
#指定要捕获的异常类型 写法2
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
except ValueError:
    print("请输入数字") #数字错误
except ZeroDivisionError:
    print("除数不能为0") #除0错误
except BaseException:
    print("出错了") #所有错误类型
else:
    print("res:",res)
finally: #不管有没有错，都会执行
    print("用户计算完毕，计算结束")
    

嵌套的异常处理

try:
    f = open("w.txt")
    for line in f:
        3/0
        print(line,end="")
except ZeroDivisionError:
    print("除数不能为0")
finally:
    if f: #如果f存在就执行下面的
        f.close()

try:
    f = open("w.txt")
    for line in f:
        try: #这样做 虽然有错误，但是不影响正常的文件读取
            3/0
        except ZeroDivisionError:
            print("计算错误")
        print(line,end="")
except ZeroDivisionError:
    print("除数不能为0")
finally:
    if f: #如果f存在就执行下面的
        f.close()

with 上下文管理

#with 上下文管理
#省略f.close()代码，实现自动关闭
with open("w.txt","r",encoding="gbk") as f: #f等于 f = open("w.txt")
    for line in f:
        print(line,end="")

图片复制

#图片复制
with open("wallhaven-z8jl7w.jpg","rb") as fin: #读取一个图片，存在的
    with open("wallhaven-z8jl7w-2.jpg","wb") as fout: #新建一个图片
        for data in fin:#循环已在的图片数据
            fout.write(data)##循环已在的图片数据,然后写入

#图片复制,同时打开两个文件
with open("wallhaven-z8jl7w.jpg","rb") as fin,open("wallhaven-z8jl7w-3.jpg","wb") as fout:
    for data in fin:#循环已在的图片数据
        fout.write(data)##循环已在的图片数据,然后写入

debug

导入模块

#导入模块也可以起别名
import mymou as m

if __name__ == '__main__':
 把脚本变量写在这下面 ,函数可以写在之外   

方式2：把变量写在一个函数中，然后再引用
def main():
    a = 10
    print(a)
if __name__ == '__main__':
    main()
#添加新的路径    
import sys
print(sys.path)
sys.path.append("d:\lib\haha")

#查看内置模块名称
import sys
print(sys.builtin_module_names)

import os
print(__file__)
D:\Users\Administrator\PycharmProjects\pythonProject\demowenjian.py

import os
print(__file__)
#获取不同操作系统的路径
print(os.path.dirname(__file__))
D:\Users\Administrator\PycharmProjects\pythonProject\demowenjian.py
D:\Users\Administrator\PycharmProjects\pythonProject

import sys
import os
print(os.path.dirname(__file__) + r"/lib")
sys.path.append(os.path.dirname(__file__) + r"/lib")
print(sys.path)

D:\Users\Administrator\PycharmProjects\pythonProject/lib
['D:\\Users\\Administrator\\PycharmProjects\\pythonProject', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject\\venv', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject\\venv\\lib\\site-packages', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject/lib']

#直接引用函数 08是模块名  ipaddress是函数名称
from day08 import ipaddress
print(ipaddress)

#直接引用所有函数 有弊端
from day08 import *

#还能起别名
from day08 import ipaddress as ip