敏感词列表 li = [“大大大”, “好黑”, “真大”, “真长”]
将用户输入的内容中的敏感词汇替换成等长度的*（大大大就替换***），并添加到一个列表中；如果用户输入的内容没有敏感词汇，则直接添加到新列表中。
lst=[]
while True:
strvar = input('请输入您的内容')
#按Q退出
if strvar.upper()=='Q':
print(lst)
break
for i in li:
#寻找敏感词汇
if i in strvar:
strvar=strvar.replace(i,'*'*len(i))
lst.append(strvar)
循环打印列表中的每个元素,并转化为小写，遇到列表则再循环打印出它里面的元素。
for i in li :
# 判断是否是字符串
if isinstance(i,str):
print(i.lower())
# 判断是不是列表
# elif isinstance(i,(list,tuple)):
elif type(i) == list:
for j in i :
if isinstance(j,str):
print(j.lower())
else:
print(j)
# 其他情况正常打印
else:
print(i)
将字符串strvar="k:1|k1:2|k2:3|k3:4"处理成字典{‘k’:1,‘k1’:2,‘k2’:3,‘k3’:4}
lst = strvar.split("|")
print(lst)
dic = {}
for i in lst:
# print(i.split(":"))
k,v = i.split(":")
print(k,v)
dic[k] = int(v)
print(dic)
li= [11,22,33,44,55,66,77,88,99,90],
将大于 66 的值保存至字典的k1键中，
将小于 66 的值保存至字典的k2键中。
# 即： {‘k1’: 大于66的所有值列表, ‘k2’: 小于66的所有值列表}
li= [11,22,33,44,55,66,77,88,99,90]
dic = {"k1":[] , "k2":[]}
for i in li:
if i > 66:
dic["k1"].append(i)
elif i < 66:
dic["k2"].append(i)
print(dic)
文件a.txt内容：每一行内容分别为商品名字，价钱，个数。
apple 10 3
tesla 100000 1
mac 3000 2
lenovo 30000 3
chicken 10 3
变成如下数据格式,并计算出总价格
[
{'name':'apple','price':10,'amount':3},
{'name':'tesla','price':1000000,'amount':1}
]
lst_total = []
money_count = 0
with open("a3.txt",mode="r+",encoding="utf-8") as fp:
# 把数据读取到列表
lst = fp.readlines()
print(lst)
# 循环列表数据
for i in lst:
dic = {}
# 得到的字符串按照空格分隔=>列表
lst2 = i.strip().split()
# print(lst2) # ['apple', '10', '3']
# 为字典添加键值对
dic["name"] = lst2[0] # 名字
dic["price"] = int(lst2[1]) # 价格
dic["amount"] = int(lst2[2]) # 数量
# 将新子典插入到列表中
lst_total.append(dic)
# 计算总价格 = 单价 * 数量 = 当前商品总价
money_count += dic["price"] * dic["amount"]
打印列表
print(lst_total)
print(money_count)
定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
def func(lst):
# 方法一
# return lst[1::2]
# 方法二
for i in range(1,len(lst),2):
print(lst[i])
#lst = ["a","b","c","d"]
func(lst)
print(func(lst))
定义函数: ,接收一个参数(可迭代性数据) ,用_让元素相连成字符串 ,打印出来
def func(container):
for i in range(len(lst)):
# 直接把强转的字符串赋值给原来的位置
lst[i] = str(lst[i])
print(lst)
return "_".join(lst)
lst = [ 1 ,2 ,3 ,4 ,5 ,6]
res = func(lst)
print(res)
接受任意参数,打印其中最小值
方法一
def func(*args):
print(args)
lst = list(args)
lst.sort()
return lst[0]
print( func(1,2,3,-100,99,-200) )
方法二 可以传递一级容器,但是不限定数据类型
def func(*args):
lst_new = []
# print(args)
for i in args:
# 判断是整型或者浮点型
if isinstance(i,(int , float)):
lst_new.append(i)
elif isinstance(i , (list,tuple,set,dict)):
# 判断类型如果是字典
if isinstance(i, dict):
i = i.values()
# 循环检测是不是整型或者小数
for j in i:
if isinstance(j,(int , float)):
lst_new.append(j)
lst_new.sort()
return lst_new[0]
lst = func(1,2,3,6.7,"abc","啊你",[11,12,13],{"100",200},(100,-100), {"a":-300,"b":-600})
print(lst)
写函数，用户传入要修改的文件名，与要修改的内容，执行函数，修改操作
方法一
def func(filename,str1,str2):
# 读出来
with open(filename,mode="r+",encoding="utf-8") as fp:
strvar = fp.read()
# 替换完写进去
with open(filename,mode="w+",encoding="utf-8") as fp:
# 替换字符串
strvar = strvar.replace(str1,str2)
# 写进去
fp.write(strvar)
# print(strvar)
func("ceshi.txt","你好","你不好")
方法二
def func(filename,str1,str2):
with open(filename,mode="r+",encoding="utf-8") as fp:
strvar = fp.read()
strvar = strvar.replace("你不好","你好")
# 把光标移动到开头
fp.seek(0)
# 截取0个字节 <==> 清空文件
fp.truncate()
fp.write(strvar)
func("ceshi.txt","你不好","你好")
写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
方法一
def func(strvar):
if isinstance(strvar,str):
dic = {"num":0,"word":0,"space":0,"other":0}
for i in strvar:
print(i)
if i.isdecimal():
dic["num"] += 1
elif i.isalpha():
dic["word"] += 1
elif i.isspace():
dic["space"] += 1
else:
dic["other"] += 1
return dic
res = func("sjfksP你好jdkf 23 34&**(&*")
print(res)
方法二
def func(strvar):
if isinstance(strvar,str):
dic = {"num":0,"word":0,"space":0,"other":0}
for i in strvar:
print(i)
if i in "0123456789":
dic["num"] += 1
elif i.lower() in "abcdefghijklmnopqrstuvwxyz":
dic["word"] += 1
elif i == " ":
dic["space"] += 1
else:
dic["other"] += 1
return dic
res = func("ABC-1你好jdkf 23 34&**(&*")
print(res)
写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，返回处理后的结果.
#例:参数为:dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def func(dic):
lst = []
if isinstance(dic,dict):
val = dic.values()
for i in val:
print(i)
if isinstance(i,(str,list,tuple)):
lst.append(i[:2])
return lst
dic = {"k1": "v1v1", "k2": [11,22,33,44],"k3":123}
lst = func(dic)
print(lst)
传入多个容器类型数据,计算所有元素的个数
def func(*args):
total = 0
for i in args:
total += len(i)
return total
res = func((1,2,3),[4,5,6],{7,8,9},"abc",{"a":1,"b":2})
print(res)
可滑动的序列 自定义一个函数 根据参数n的值，变成对应个元素的容器 （zip）
listvar = [1,2,3,4,5,6,7,8,9]
n = 2
listvar = [[1,2],[3,4],[5,6],[7,8]]
n = 3
listvar = [[1,2,3],[4,5,6],[7,8,9]]
n = 4
listvar = [[1,2,3,4],[5,6,7,8]]
n = 2
lst1 = [1,3,5,7,9]
lst2 = [2,4,6,8]
切片
lst1 = lst[0::2]
lst2 = lst[1::2]
it = zip(lst1,lst2)
print(list(it))
n = 3
lst1 = [1,4,7]
lst2 = [2,5,8]]
lst3 = [3,6,9]
切片
lst[0::3]
lst[1::3]
lst[2::3]
it = zip(lst1,lst2,lst3)
print(list(it))
n = 4
lst1 = [1,5,9]
lst2 = [2,6]
lst3 = [3,7]
lst4 = [4,8]
切片
lst1 = lst[0::4]
lst2 = lst[1::4]
lst3 = lst[2::4]
lst4 = lst[3::4]
it = zip(lst1,lst2,lst3,lst4)
print(list(it))
lst = [1,2,3,4,5,6,7,8,9]
n = 2
print([lst[i::n] for i in range(n)])
n = 3
print([lst[i::n] for i in range(n)])
n = 4
print([lst[i::n] for i in range(n)])
[ [1, 5, 9], [2, 6], [3, 7], [4, 8] ]
列表推导式 => 截取出对应的几个列表
[ lst[i::n] for i in range(n) ]
将列表中的元素进行解包,通过参数一个一个传递;
*[ lst[i::n] for i in range(n) ]
it = zip(*[lst[i::n] for i in range(n)])
print(list(it))
*号在函数的调用处用来解包.
def func(a,b,c):
print(a,b,c)
lst = [1,2,3]
func(*lst)
最终答案
lst = [1,2,3,4,5,6,7,8,9]
def func(n):
return zip(*[lst[i::n] for i in range(n)])
print("<====>")
lst = [1,2,3,4,5,6,7,8,9]
func = lambda n : zip(*[lst[i::n] for i in range(n)])
it = func(4)
print(list( map(list,it) ))
青蛙跳台阶
一只青蛙要跳上n层高的台阶
一次能跳一级,也可以跳两级
请问这只青蛙有多少种跳上这个n层高台阶的方法?
"""
n = 1 => 1: 1
n = 2 => 2: 1 1 | 2
n = 3 => 3: 1 1 1 | 1 2 | 2 1
n = 4 => 5: 1 1 1 1 | 1 1 2 | 1 2 1 | 2 1 1 | 2 2
n = 5 => 8: 1 1 1 1 1 | 1 1 1 2 | 1 1 2 1 | 1 2 1 1 | 2 1 1 1 | 2 2 1 | 2 1 2 | 1 2 2
1 2 3 5 8 类似于斐波那契;
"""
def fib(n):
if n == 1 or n == 2:
return n
return fib(n-1) + fib(n-2)
print(fib(2))
2.递归反转字符串 “将14235 反转成53241”
strvar = "12345"
length = len(strvar)
print(length)
函数的定义
def func(lth,lst = []):
# 如果字符串总长度为0,代表所有数据装载完毕,返回列表
if lth == 0 :
return lst
# 取字符串最后一个元素
res = strvar[lth-1]
# 塞新的列表里
lst.append(res)
# 携带着新的列表,进入到下一个函数空间存值;
return func(lth-1,lst)
函数的调用
"""length <=> lth 一一对应 , lst实参没传,使用默认列表"""
lst = func(length)
res = ''.join(lst)
print(res, type(res))
让用户输入输入内容 且机会只有3次
方法一
num = 66
times = 1
while times <= 3:
n = input("请输入数字:")
if n.isdecimal():
n = int(n)
if n > 66:
print("猜测的结果大了")
elif n < 66:
print("猜测的结果小了")
else:
print("猜对了 ok")
break
else:
print("这不是一个数字")
if times == 3:
print("都没猜对,继续努力")
times +=1
方法二
num = 66
flag = True
times = 1
while flag:
n = input("请输入数字:")
if n.isdecimal():
n = int(n)
if n > 66:
print("猜测的结果大了")
elif n < 66:
print("猜测的结果小了")
else:
print("猜对了 ok")
break
else:
print("这不是一个数字")
if times == 3:
print("都没猜对,继续努力")
flag = False
times +=1
打印菱形小星星
*
***
*****
*******
*********
***********
***********
*********
*******
*****
***
*
13 => 7
11 => 6
9 => 5
7 => 4
对于任意个星星n,一共是多少行?
hang = n // 2 + 1
1 => 5
2 => 4
3 => 3
4 => 2
5 => 1
对于当前行i,有多少个空格
kongge = hang - i
1 => 1
2 => 3
3 => 5
4 => 7
5 => 9
对于当前行i,有多少个星星
xingxing = i*2 - 1
方法一
n = 11
hang = n // 2 + 1
i = 1
while i <= hang:
# 遍历空格
kongge = hang - i
print(" " * kongge,end="")
# 遍历星星
xingxing = i*2 - 1
print("*" * xingxing , end="")
# 打印换行
print()
i+=1
把星星到过来 (倒序)
i = hang
while i>0:
# 遍历空格
kongge = hang - i
print(" " * kongge,end="")
# 遍历星星
xingxing = i*2 - 1
print("*" * xingxing , end="")
# 打印换行
print()
i-=1
方法二
n = 11
hang = n // 2 + 1
i = 1
while i <= hang:
# 遍历空格
kongge = hang - i
# print(" " * kongge,end="")
while kongge > 0:
print(" ",end="")
kongge -= 1
# 遍历星星
# xingxing = i*2 - 1
# print("*" * xingxing , end="")
xingxing = 1
while xingxing <= i*2 - 1:
print("*",end="")
xingxing += 1
# 打印换行
print()
i+=1
i = hang
while i > 0:
kongge = hang-i
# 遍历空格
while kongge > 0:
print(" ",end="")
kongge -= 1
# 遍历星星
xingxing = 1
while xingxing <= i*2 - 1:
print("*",end="")
xingxing += 1
# 打印换行
print()
i-=1
方法三 (for循环的)
n = 11
hang = n // 2 + 1
for i in range(1,hang+1):
kongge = hang - i
xingxing = i*2 - 1
# 打印空格
print(" " * kongge,end="")
# 打印星星
print("*" * xingxing)
for i in range(hang,0,-1):
kongge = hang - i
xingxing = i*2 - 1
# 打印空格
print(" " * kongge,end="")
# 打印星星
print("*" * xingxing)
找出敏感词汇
通用写法
while True:
sign = False
strvar = input("请输入字符串:")
lst = ["粉嫩","铁锤"]
# 找字符串中是否含有敏感词汇.
for i in lst:
if i in strvar:
# 设置sign这个标记为True 代表敏感词汇
sign = True
print("有敏感词汇")
# 如果没有被标记成True ,代表可以使用
if sign == False:
print("可以使用")
python特有
基本语法
#for ... else
遇到break 终止了循环, else分支的代码块内容不执行
for i in range(3):
print(i)
if i == 2:
break
else:
print("ok")
while True:
strvar = input("请输入字符串:")
lst = ["粉嫩","铁锤"]
# 找字符串中是否含有敏感词汇.
for i in lst:
if i in strvar:
print("有敏感词汇")
break
else:
print("可以使用")
登录小程序
账户密码会预先记录在文件中
输入账号密码:如果都正确,登录成功
如果用户登录时进行三次校验,都不对,记录黑名单文件中
如果是黑名单的用户,禁止下次再次登录
思路:首先要设置账户和密码还有黑名单空列表,先输入你的账户,打开文件,把账户和密码添加到新的列表中,判断账户是否存在,存在就打开黑名单,把黑名单放到新的列表中,判断是否在黑名单,没有在,就开始循环,输入密码(密码的索引和账户索引一样),循环3次,密码错误要打开黑名单写进去
存放账户
accountlist = []
存放密码
pwdlist = []
存放黑名单用户
blacklist = []
sign = True
while sign:
username = input("请输入您的用户名:")
print(username)
# 1.获取用户密码等数据
with open("user.txt",mode="a+",encoding="utf-8") as fp:
fp.seek(0)
lst = fp.readlines()
# print(lst) # ['ceshi1:111\n', 'ceshi2:222\n', 'ceshi3:333']
# 提取文件里面的账户和密码
for i in lst:
account , pwd = i.strip().split(":")
# print(account , pwd)
accountlist.append(account)
pwdlist.append(pwd)
print(accountlist)
print(pwdlist)
# 2.判定是否存在该用户
if username in accountlist:
# 3.判断是不是黑用户
with open("black.txt",mode="a+",encoding="utf-8") as fp:
fp.seek(0)
lst = fp.readlines()
for i in lst:
# print(i)
blacklist.append(i.strip())
print(blacklist)
if username in blacklist:
print("抱歉,您的账户被冻结...")
else:
# 允许用户输入账号 密码:
num = accountlist.index(username)
print(num) # pwdlist[num] 是username 对应的密码
# 检查输入的次数为三次
times = 0
while times < 3: # 0 1 2
pwd = input("请输入您的密码:")
if pwd == pwdlist[num]:
# 如果都正确,程序结束.
print("恭喜你~ 登录成功~")
sign = False
break
else:
# 剩余次数 = 总次数 - 当前次数
print("密码输入错误,你还剩下%s次机会" % (2-times))
if times == 2:
print("因为密码错了三次,您的账户被冻结...")
# 记录黑名单文件中
with open("black.txt",mode="a+",encoding="utf-8") as fp:
res = username + "\n"
fp.write(res)
times += 1
else:
print("该用户根本不存在")
构建如下列表：[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
lst = [ (i,i+1) for i in range(6) ]
print(lst)
把M中3,6,9组成新列表
M = [[1,2,3],[4,5,6],[7,8,9]]
lst = [j for i in M for j in i if i.index(j) == 2]
print(lst)
lst = [i[-1] for i in M ]
print(lst)
用推导式写如下程序
lst1 = {
'name':'alex',
'Values':[
{'timestamp': 1517991992.94,'values':100,},
{'timestamp': 1517992000.94,'values': 200,},
{'timestamp': 1517992014.94,'values': 300,},
{'timestamp': 1517992744.94,'values': 350},
{'timestamp': 1517992800.94,'values': 280}
]
}
将lst1 转化成如下lst2:
lst2 = [
[1517991992.94, 100],
[1517992000.94, 200],
[1517992014.94, 300],
[1517992744.94, 350],
[1517992800.94, 280]
]
lst = [ [i["timestamp"],i["values"]] for i in lst1["Values"] ]
print(lst)
或
lst2 = [[i for i in j.values()] for j in lst1["Values"]]
print ( lst2 )
读取一个文件所有内容,通过生成器调用一次获取一行数据.
'''文件对象是迭代器'''
def readfile():
with open("ceshi.txt",mode="r+",encoding="utf-8") as fp:
for i in fp:
# 一次读取一行
# print(i)
yield i
gen = readfile()
res = next(gen)
res = next(gen)
print(res)
注册
(1)检测两次密码如果相同,确认注册成功
(2)检测两次密码如果不同,提示两次密码不一致
(3)用户名不能重复
思路;先打开文件,把账户放到新的列表当中.请注册账户,判断账户是否有非法字符,以及账户是否存在,然后输入注册密码,第二次跑循环,在判断两次密码是否正确.
用来 存放所有账户的列表 accountlist
accountlist = []
sign = True
with open("user.txt",mode="a+",encoding="utf-8") as fp:
while sign:
username = input("请输入要注册的用户名:")
if ' ' in username or username == '':
print("对不起,改名字含有非法字符")
else:
# 不能含有重复的用户名
fp.seek(0)
lst = fp.readlines()
for i in lst:
k = i.strip().split(":")[0]
accountlist.append(k)
print(accountlist)
# 如果用户名在这个accountlist中,说明该用户注册过了
if username in accountlist:
print("该用户已经存在")
else:
# 允许用户注册 , 提示输入密码
pwd = input("请输入您的密码")
while True:
pwd2 = input("请确认您的密码")
if pwd == pwd2:
print("恭喜你,注册成功~")
strvar = username + ":" + pwd + "\n"
fp.write(strvar)
sign = False
break
elif pwd2.upper() == "Q":
break
else:
print("你两次不一致")
匹配整数或者小数（包括正数和负数）
[+-]?\d+(\.\d+)?
匹配年月日日期 格式 2018-12-31
01 02 03 4 5 6 7 8 9 10 11 12 1 2 3 11 12 13 21 22 23 30 31
([1-9]\d{3})-(0?[1-9]|1[0-2])-(0?[1-9]|1[0-9]|2[0-9]|3[01])
([1-9]\d{3})-(0?[1-9]|1[0-2])-(0?[1-9]|[12]\d|3[01])
11位的电话号码
^1[3-9]\d{9}$
匹配邮箱地址 邮箱规则 123463922@qq.com 123@abc.com.cn
@之前必须有内容且只能是字母,数字,下划线(_),减号(-),点(.)
[\w\-\.]+
@符号后面是字母,数字,减号(-),保留121@qq.com.cn 的可能
@[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)?
最后一个点(.)之后必须有内容,字母,数字且长度为大于等于2个字节,小于等于6个字节
\.[a-zA-Z0-9\-]{2,6}
[\w\-\.]+@[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)?\.[a-zA-Z0-9\-]{2,6}
'1-2*((60-30+(-40/5)(9-25/3+7/399/42998+10568/14))-(-43)/(16-3*2))'从上面算式中匹配出最内层小括号以及小括号内的表达式
import re
strvar = '1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
obj = re.search("\([^()]+\)",strvar)
print(obj.group())
已经不能再表达是括号的情况下才是最里层,再也没括号
正则小程序:给你字符串 ‘1-2*((60-30+(-40/5)(9-25/3+7/399/42998+10568/14))-(-43)/(16-3*2))’ 计算最后结果.
思路:先要去掉空格,然后去括号,在操作计算,去完第一个括号,要去操作计算第一个括号里面的乘除加减,然后返回到去括号的函数中,返回一个字符串,通过主函数的调用操作计算函数可得结果
import re
strvar = "1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))" # 2776672.6952380957
处理符号
def sign_exp(strvar):
strvar = strvar.replace("+-","-")
strvar = strvar.replace("--","+")
strvar = strvar.replace("-+","-")
strvar = strvar.replace("++","+")
return strvar
计算表达式
def calc_exp(strvar):
# 判断字符串是 乘法 还是 除法
if "*" in strvar:
a,b = strvar.split("*")
return float(a) * float(b)
if "/" in strvar:
a,b = strvar.split("/")
return float(a) / float(b)
操作表达式
def opreate_exp(strvar):
# 先算乘除
while True:
# (40+5*-2+3/2)
# 匹配 [谁*谁] 或者 [谁/谁] 例: 5*-2 3/2
obj = re.search(r"\d+(\.\d+)?[*/][+-]?\d+(\.\d+)?",strvar)
if obj:
res1 = obj.group()
# print(res1) # 5*-2
# 计算表达式的结果
res2 = calc_exp(res1)
# print(res2 , type(res2)) # -10.0 <class 'float'>
# 将所得的结果,替换到原来的字符串当中,以匹配下一个乘法或者除法
strvar = strvar.replace(res1,str(res2))
# print(strvar) # (40+-10.0+3/2)
else:
# 当obj 返回None的时候停止
break
# 处理表达式中的符号
strvar = sign_exp(strvar)
# print(strvar) # (40+-10.0+1.5) (40-10.0+1.5)
# 计算剩下+-的表达式(将每一个数字匹配出来,做累加)
lst = re.findall("[+-]?\d+(?:\.\d+)?",strvar)
# print(lst) # ['40', '-10.0', '+1.5']
total = 0
for i in lst:
total += float(i)
# print(total) # 31.5
return total
移除括号
def remove_bracket(strvar):
while True:
obj = re.search("\([^()]+\)",strvar)
# print(obj)
if obj:
res1 = obj.group()
# print(res1) # (40+5*-2+3/2) "-30+(40+5*-2+3/2)*8 +(4-7)"
# 计算一个括号里面表达式的值
res2 = opreate_exp(res1)
# print(res2) # 31.5
# 替换原来的括号,消除括号
strvar = strvar.replace(res1,str(res2))
# print(strvar) # -30+31.5*8+(4-7)
else:
return strvar # 返回一串没有括号的表达式
main函数当中不写逻辑,只调用相关的功能
def main(strvar):
# 1.整理数据,把没用的空格去掉
strvar = strvar.replace(" ","")
# 2.移除所有括号
strvar = remove_bracket(strvar)
# print(strvar) # -30+31.5*8+-3.0
# 3.计算表达式
return opreate_exp(strvar)
res = main(strvar)
print(res) # 219.0
自己创建类,实例化对象,在终端输出:
小明 ,10岁,男,上山去砍柴
小明 ,10岁,男,开车去东北
小明 ,10岁,男,最爱大保健
小明 ,10岁,男,上山去砍柴
小明 ,10岁,男,开车去东北
小明 ,10岁,男,最爱大保健
class Person():
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def print_str(self):
strvar = """
{0}，{1}岁，{2}，上山去砍柴
{0}，{1}岁，{2}，开车去东北
{0}，{1}岁，{2}，最爱大保健
"""
print(strvar.format(self.name,self.age,self.sex))
p1 = Person("小明",10,"男")
p1.print_str()
p2 = Person("刘伟",78,"男")
p2.print_str()
创建一个lol类,构造方法中给对象name,ad(攻击力),hp(血量),三个属性,通过ATTACK方法,接收两个对象,要完成谁攻击谁,掉了多少血,还是多少血的提示
对象变化用init
class Game_role():
def __init__(self,name,ad,hp):
self.name = name
self.ad = ad
self.hp = hp
def attack(self,obj):
obj.hp -= self.ad
strvar = "{}攻击{},{}掉了{}血, 还剩{}血"
print(strvar.format(self.name,obj.name,obj.name,self.ad,obj.hp))
p1 = Game_role("盖伦",10,100)
p2 = Game_role("剑豪",20,80)
p1.attack(p2)
定义一个圆形类,求周长和面积,圆的半径通过参数给初始化
import math
class Circle():
def __init__(self,r):
self.r = r
def zhouchang(self):
return 2 * math.pi * self.r
def mianji(self):
return math.pi * pow(self.r,2)
obj = Circle(5)
print(obj.zhouchang())
print(obj.mianji())
创建AB两个类，A类中有属性abc=5把A类的对象存储在B类对象的成员属性pty中,用B类对象调用出abc这个值.
class A():
abc = 51
class B():
def __init__(self,obj):
self.pty = obj
obj1 = A()
obj2 = B(obj1)
print(obj1.abc) # 51
print(obj2.pty) # <__main__.A object at 0x0000024771ACE828>
print(obj2.pty.abc)
或
class A():
abc=58
obj=A()
class B():
pty=obj
obj1=B()
print(obj1.pty.abc)
读程序写结果.(不执行)
#在类内可以创建对象的私有成员,但是没什么太大意义
class JustCounter:
__secretCount = 0
def count(self):
print(self.__secretCount) # 获取
self.__secretCount += 1
"""★★★★★
self.__secretCount = self.__secretCount + 1
self.__secretCount = 0 + 1 = 1
self.__secretCount = 1 为当前对象添加私有成员__secretCount 值为1
为对象的私有属性赋值,添加一个私有成员,不是类的,因为是self点私有属性
"""
def count3():
print(JustCounter.__secretCount)
JustCounter.__secretCount += 1
print(JustCounter.__secretCount)
class Bars(JustCounter):
def count2(self):
print(self.__secretCount)
情况一
counter1 = JustCounter()
counter1.count() # 0 第一次是获取私有成员★★★★★
counter1.count() # 1 第二次是为对象创建一个私有成员,第二次打印的是对象在类内创建的私有成员,不是类的私有成员★★★★★
JustCounter.count3() # 0 1 类调用类的私有成员
情况二
counter2 = Bars()
counter2.count() # 1
counter2.count() # 2
情况三
JustCounter.count3() # 0 1
连贯操作
#通过点( . )不断的调用下一个对象的操作就是连贯操作
class my1():
def func1(self):
print('我是my1')
class my2():
def __init__(self,obj):
self.pty1=obj
class my3():
def __init__(self, obj):
self.pty2 = obj
obj1=my1()
obj2=my2(obj1)
obj3=my3(obj2)
obj3.pty2.pty1.func1()==>我是my1
小人射击★★★★★
用面向对象的思维完成该程序,要求:
1:子弹可以装载到弹夹中
2:弹夹可以装载到枪支中
3:人具有拿枪射击的功能,也可以换子弹
#面向对象的思维,一个类一个文件,把所有类的文件放到一个文件夹中,然后在同级创建一个主文件(main),然后用主文件(main)统一调用,main只负责调用
#面向对象的核心思想:把对象作为程序的最小单元,让对象操作一切★★★★★
第一步 先想一下总体步骤(思路)
'''
弹夹类:BulletBox
属性:子弹数量可以增加 bulletcount
方法: 无
枪类 Gun
属性: 可以装载弹夹(对象)
方法: 用来射击shoot
人类 Person
属性: 拿枪(对象)
方法: 拿枪射击shoot 换子弹
'''
第二步 创建一个文件夹,在文件夹中创建3个类文件
#弹夹类 BulletBox
class BulletBox():
def __init__(self,bulletcount):
self.bulletcount=bulletcount
#枪支类 Gun
class Gun():
def __init__(self,BulletBox):
self.BulletBox=BulletBox
def shoot(self,shootcount):
#通过self调用自己的BulletBox属性得到一个弹夹对象,在通过弹夹对象.bulletcount属性得到子弹的一个数量
if self.BulletBox.bulletcount <= shootcount:
print('对不起,子弹数量不够,请先上子弹')
else:
#开始射击
#剩余子弹=总数量-已经射出的数量
self.BulletBox.bulletcount -= shootcount
print('哒'*shootcount,'还剩下{}颗子弹'.format(self.BulletBox.bulletcount))
#人类 Person
class Person():
def __init__(self,Gun):
self.Gun=Gun
#射击
def shoot(self,shootcount):
self.Gun.shoot(shootcount)
#上子弹
def addcount(self,num):
self.Gun.BulletBox.bulletcount +=num
#self.Gun==>枪对象
#self.Gun.BulletBox==>弹夹对象
#self.Gun.BulletBox.bulletcount==>子弹数量
第三步 在文件夹同级创建一个主文件,导入文件夹中的类(具体到文件夹中文件里面的类),统一调用
from package.BulletBox import BulletBox
from package.Gun import Gun
from package.Person import Person
#先创建一个弹夹
danjia=BulletBox(20)
#在创建一杆枪
jiatel=Gun(danjia)
#在创建一个人
xboy=Person(jiatel)
#防止文件当成模块导入其他文件
#小人射击
if __name__=='__main__':
xboy.shoot(1)
xboy.addcount(100)
xboy.shoot(80)
### 购物车
import json
import time
money = 0
goods_lst = []
定义一个购物车字典
car = {}
"""
car = {
1:{电脑... }
2:{鼠标...}
}
"""
with open("shopping_data.json" , mode="r+",encoding="utf-8") as fp:
for i in fp:
dic = json.loads(i)
goods_lst.append(dic)
print(goods_lst)
"""
[
0:{'name': '电脑', 'price': 1999}, 1
1:{'name': '鼠标', 'price': 10,"account":2}, 2
2:{'name': '游艇', 'price': 20}, 3
3:{'name': '美女', 'price': 998}, 4
4:{'name': '风油精', 'price': 30} 5
]
"""
def progress(percent):
if percent > 1:
percent = 1
strvar = int(50 * percent) * "#"
print("\r[%-50s] %d%%" % (strvar , int(100 * percent)) ,end="")
def exe_progress():
recv_size = 0
# 假设文件总大小是 1028000
total_size = 1028000
while recv_size < total_size:
time.sleep(0.01)
# 一次接受的字节数是1024
recv_size += 6000
percent = recv_size/total_size
progress(percent)
充值
def recharge():
global money
while True:
num = input("请充值吧,大哥")
if num.isdecimal():
money = int(num)
print("恭喜你~ 充值成功{}元人民币".format(money))
print(money)
break
else:
print("充值失败,非数字.")
加载
def loading():
print("加载商品中 ... ")
exe_progress()
print()
展示
def show_goods():
strvar = "{}".format("商品名称").center(18)
print("序号" + strvar + "价格")
# 打印对应的商品
for k,v in enumerate(goods_lst,start=1):
# print(k,v)
v['num'] = k
strvar = "{v[num]:<10}{v[name]:<12}{v[price]}".format(v=v)
print(strvar)
def error():
strvar = """
**************************************************
* 您输入的选项不存在 , 请重新输入 *
**************************************************
"""
print(strvar)
time.sleep(1)
def add_car(num):
if num not in car:
car[num] = {
"name": goods_lst[num-1]["name"],
"price": goods_lst[num-1]["price"],
"account": 1
}
else:
car[num]["account"] += 1
print(car)
"""
{
序号: 商品描述(字典形式展现)
2: {'name': '鼠标', 'price': 10, 'account': 1},
3: {'name': '游艇', 'price': 20, 'account': 1}
}
"""
def show_car(num):
print("*" * 50 )
print("您选择的商品具体信息:")
print("*-商品名称:{}".format(car[num]["name"]))
print("*-商品单价:{}".format(car[num]["price"]))
print("*-商品数量:{}".format(car[num]["account"]))
print("已成功添加到购物车~ 请继续shopping ~")
print("*" * 50 )
def balance():
total = 0
print("[-------------------您购物车的具体商品如下:-------------------]")
for k,v in car.items():
print(k,v)
v["num"] = k
# 计算当前商品总价格
v["total"] = v["price"] * v["account"]
# 计算所有商品总价格
total += v["total"]
strvar = "序号{v[num]}: 商品名称:{v[name]} 商品单价:{v[price]} 商品数量:{v[account]} 此商品总价:{v[total]}".format(v=v)
print(strvar)
return total
def success(total,money):
print("正在结算数据中 ... ")
exe_progress()
print("\n请稍后...")
time.sleep(1)
print("[一共：{}元]".format(total))
print("[您已经成功购买以上所有商品 , 余额还剩{}元，感谢您下次光临~]".format(money-total))
def del_goods(total,money):
print("余额不足，还差{}元，请忍痛割爱，删除某些商品".format(total-money))
num = input("[-------------------请输入要删除的商品序号:-------------------]")
# 判断是不是纯数字
if num.isdecimal():
# 变成数字类型
num = int(num)
# 判断该商品在不在购物车当中
if num in car:
# 数量-1
car[num]["account"] -= 1
# 如果数量变成了0,意味着从购物车中删除该商品
if not car[num]["account"]:
car.pop(num)
else:
error()
else:
error()
def myexit():
print("[============== 欢迎下次光临: ==============]")
time.sleep(1)
主文件调用
def main():
# 1.充值
recharge()
# 2.加载中
# loading()
# 3.展示商品
show_goods()
# 4.开始购物
sign = True
while sign:
num = input("请输入您要购买的商品:")
# 购物
if num.isdecimal():
num = int(num)
if num <= len(goods_lst):
# 添加购物车
add_car(num)
# 展示购物车
show_car(num)
else:
error()
# 结算
elif num.upper() == "N":
while True:
# 结算总价格
total = balance()
# print(total,money) # 10 0
# 判断总价格超过实际充值,提示用户删除商品
if total > money:
# 删除商品
del_goods(total,money)
else:
# 成功购买
success(total,money)
sign = False
break
# while True:
# 开始计算
# total = balance()
# if 结算的价格 > 充值的钱:
# 删除商品操作
# else:
# 展现购买成功的信息
# break
# 退出
elif num.upper() == "Q":
myexit()
sign = False
else:
# 报错
error()
main()
求res是多少?
题:
def func():
return [lambda x : i*x for i in range(4)]
res = [m(2) for m in func()]
思路:[lambda x : i*x for i in range(4)]
1.里面放了个匿名函数 错误
[ lambda表达式(匿名函数) ]
lambda 参数 : 返回值
"""这个写法是错误的,因为返回值没有加[]{}()括号,不是推导式"""
func = lambda x : i*x for i in range(4)
func(3) # SyntaxError: invalid syntax
2.是列表推导式,里面放了4个函数
[ lambda x : i*x , lambda x : i*x , lambda x : i*x , lambda x : i*x ]
转换为:
lst = []
def func():
for i in range(4):
def ceshi(x):
return i*x
lst.append(ceshi)
return lst
lst = func()
print(lst)
res = [m(2) for m in func()]
将返回的内函数遍历
def ceshi(x):
return i*x
[ceshi(2),ceshi(2),ceshi(2),ceshi(2)]
[return 2*i , return 2*i , return 2*i , return 2*i]
[2*3,2*3,2*3,2*6] => [6,6,6,6]
在这个环节开始调用函数.才去执行其中的代码块,里面需要i,那么就回去找i,i已经遍历4次,再回去找的时候是最后一个i,但是此刻的i已经是3了,因为闭包的原因保留了i=3这个值,所有得到的值是3,所以拿出2*3想乘,最后是4个6
思维误区:
函数的定义处
"""
函数在定义时,其中的代码是不执行的,
只有在函数调用的时候,其中的代码块才执行.
"""
for i in range(4):
# 函数的定义处
def func():
return 6
函数的调用处才会执行代码块
打印结果是多少?
题:
普通函数
def add(a,b):
return a + b
生成器函数
def test():
for r in range(4):
yield r
g=test() # g的范围: 0 1 2 3
for n in [2,10]:
# 定义2个生成器
g=(add(n,i) for i in g)
调用
print(list(g))
print(n) # n = 10 ==>当回来再去取n值得时候是最后一个
思路:
第二次循环的时候,要拿着第一次定义的这个g使用,
g=(add(n,i) for i in g) # 第一层 i 分别得到 0 1 2 3 , n = 10 add(10,0) return a + b => (10,11,12,13) 新的生成器g的范围 10 11 12 13
g=(add(n,i) for i in g) # 第二层 i 分别得到 10 11 12 13 , n = 10 add(10,10) return a+b => (20,21,22,23) 新的生成器g的范围 20,21,22,23
print(list(g)) [20,21,22,23]
如何判断输入的数是质数
#质数(素数):除了1和本身,不再被别的数整除,2是质数当中唯一的一个偶数
while True:
num = input("请输入>>>").strip()
if num.isdecimal():
num = int(num)
if num > 1:
for i in range(2,num):
if num % i == 0 :
print("不是质数")
break
else:
print("是质数")
else:
print("质数需大于1!")
else:
print("go out,乱写的人不让玩")
break
通用写法
num = int(input("请输入>>>").strip())
if num >1:
sign = False # 设置一个标记
for i in range(2,num):
if num % i == 0 :
sign = True
break
if sign == True:
print("不是质数")
else:
print("是质数")
else:
print("质数需大于1!")
函数写法:
def zhishu(n):
list1 = []
if n >1:
for i in range(2,n):
res = n % i
list1.append(res)
if 0 in list1:
print("这不是质数!")
else:
print("这是质数!")
else:
print("质数需大于1!")
zhishu(2)
955
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
