成员运算
#1)移除 name 变量对应的值两边的空格,并输出处理结果#
name = "jason"
res = name
print(res.strip())
# 2)判断 name 变量对应的值是否以 "ja" 开头,并输出结果#
name = "jason"
res = name
print(res.startswith("ja"))
# 3)判断 name 变量对应的值是否以 "N" 结尾,并输出结果#
name = "jason"
res = name
print(res.endswith("N"))
# 4)将 name 变量对应的值中的 “a” 替换为 “b”,并输出结果#
name = "jason"
print(name.replace('a','b'))
# 5)将 name 变量对应的值根据 “a” 分割,并输出结果。#
name = "jason"
print(name.split('a'))
队列与堆栈的区别
#队列
# a = []
# a.append(12)
# a.append(23)
# a.append(34)
# print(a.pop(0))
# print(a.pop(0))
# print(a.pop(0))
#堆栈
a = []
a.append(1)
a.append(2)
a.append(3)
print(a.pop())
print(a.pop())
print(a.pop())
两个列表如何找出两者的相同元素和不同元素
list1 = [1, 2, 3]
list2 = [3, 4, 5]
#先把列表转成集合，用set表示
a = set(list1)
b = set(list2)
#交集用& 差集用^
print(a & b)
print(a ^ b)
⽤户数据列表如下
# 获取⽤户输⼊的⽤户名和密码校验是否正确，如正确则打印登录成功错误则打印⽤户名或密码错误
list = [['jason', 123], ['kevin', 123], ['tony', 123]]
a = dict(list) # print(a) 把列表转换成字典 {'jason': 123, 'kevin': 123, 'tony': 123}
b =[] #创建一个空列表
for i in a:
b.append(i) #扩展b列表 把i 放进空列表 b=新列表
while True:
n = input('your name>>>:')
p = input('your password>>>:')
if n in b and p == '123': #如果变量n在列表里和p等于123
print('登录成功')
break
else:
print('错误')
break
循环
# 循环获取⽤户的⽤户名和密码
# 如果⽤户名为jason并且密码是123则打印欢迎⽼板
# 之后循环获取⽤户指令，
# 并打印正在执⾏该指令直到⽤户输⼊q退出执⾏指令 重新回到获取⽤户信息处
#定义如果用户名等于jason 密码等于123 再循环内嵌
for i in range(3):
u = input('name>>>:')
p = input('password:')
if u == 'jason' and p == '123':
print('欢迎老板')
else:
print('fuck you ')
continue
for i in range(5):
choice = input('正在执行该命令')
if choice == 'q':
break
编写猜年龄的游戏拔⾼版本
# 1、必写
# 错误的情况下只能才三次
# 正确的情况下直接推出游戏
# 2、拔高
# 三次错误之后提示用户三次机会已用完
# 问他是否继续 如果继续则再给三次机会
# 如果不继续则直接退出
age = "18" #定义：年龄等于18 开始次数为0
count = 0
for i in range(3): #当次数小于3次时 取变量sum1 当sum1等于age18时 提示猜对 结束游戏
sum1 = input("年龄是：")
if sum1 == age:
print("你TM猜对了")
break
else: #反之猜错，次数加1 当次数等于3次时提示是否继续
print("你TM猜错了")
count += 1 #增加次数：+= （上面说了count=0 那就是从0开始+1+1+1）
if count == 3:
print('是否继续，继续输入Y，结束输入N') #先打印后循环
while True:
inp = input('输入指令') #输入变量inp 当inp为Y 次数为o重新上一轮的循环
if inp == "Y":
print('重来')
cot = 0
while cot < 3:
inp_age = input("年龄")
if inp_age == age:
print("猜对了")
break
else:
print("err")
cot += 1
break
编写⽤户注册功能
# 使⽤列表套字典形式存储⽤户数据
# user_info = [{},{},{}...]
# 循环注册⽤户信息，每完成⼀次注册列表中就以字典形式维护⽤户信息 ⽤户信息的获取⾄少有⽤户名和密码
#z =[{'name': 'jason', 'pwd': 123}, {'name': 'tony', 'pwd': 123}]
user_info = []
# 循环
while True:
# 获取用户输入的用户名，密码和确认密码
in_name = input('请输入用户名：').strip()
in_psd = input('请输入密码：').strip()
re_psd = input('请确认密码：').strip()
# 如果密码和确认密码不同，则让用于重新输入
if in_psd != re_psd: #!= 是不等于
print('请输入相同的密码，傻叉')
continue
# 遍历user_info中的每个元素，每个元素都是字典
for item in user_info:
# 判断用户名是否等于字典中的name
# 如果有相等的说明用户已经被注册
if in_name == item.get('name'):
print('该用户已存在请重新注册')
# 中断for循环，重新输入
break
else:
# 如果都不相等，那么创建新字典，将in_name和in_psd分别对应name和pwd
d = {'name': in_name, 'pwd': in_psd}
# 将字典作为一个元素添加到列表中
user_info.append(d)
# 打印注册成功
print('注册成功')
print(user_info)
ATM外框
def login():
print('登入功能')
def transfer():
print('转账')
def check_banlance():
print('查询余额')
def register ():
print('注册')
func_dic={
'1':login,
'2':transfer,
'3':check_banlance,
'4':register1
}
while True:
print("""
0 退出
1 登入
2 转账
3 查询余额
4 注册
""")
choice = input('请输入命令编号，傻逼：').strip()
if not choice.isdigit():
print('傻逼，没有该命令，重新输')
continue
if choice == '0':
break
if choice in func_dic:
func_dic[choice]()
else:
print('输入的指令不存在，傻逼')
递归
第n个员工的薪水，需要回溯得到(n-1)个员工的薪水，以此类推，直到得到第一个员工的薪水，此时，salary(1)已知，因而不必再向前回溯了。然后进入递推阶段：从第一个员工的薪水可以推算出第二个员工的薪水(6000)，从第二个员工的薪水可以推算出第三个员工的薪水(7000)，以此类推，一直推算出第第四个员工的薪水(8000)为止，递归结束。需要注意的一点是，递归一定要有一个结束条件，这里n=1就是结束条件
def salary(n):
if n == 1:
return 5000
return salary(n - 1) + 1000
s = salary(4)
print(s) # 8000
例2
l = [1, [2, [3, [4, [5, [6, [7, [8]]]]]]]]
def func(l):
for item in l:
if type(item) is list:
func(item)
else:
print(item)
func(l)
递归实现二分法
nums = [3, 7, 9, 13, 21, 33, 57, 63, 78, 99]
find_num = 57
def search(nums, find_num):
mid = len(nums) // 2
if find_num > nums[mid]:
search(nums[mid + 1:], find_num)
elif find_num < nums[mid]:
search(nums[:mid], find_num)
else:
print("find it")
search(nums, find_num)
九九乘法法表
row = 1
while row <=9:
col =1
while col <= row:
print("%d * %d = %d" % (col,row,col*row),end ='\t')
#\t 字符串保持对齐 end= "" 不换行打印
col += 1
print("") #上面的print函数完成后自动换行打印
row += 1
变量参数求和
#方法1
def sum_2_sum(num1, num2):
res = num1 + num2
print("%d + %d = %d " % (num1, num2, res))
num_2_num(1, 2)
#方法2
def sum_2_sum(num1,num2)
return num1+num2
res = sum_2_sum (10,20)
print res
#方法3 设定一个数，return到那个数 停止运行
def sum_numbers(num):
if num == 1:
return 1
sum_numbers(num - 1)
temp = sum_numbers(num - 1)
return num + temp
res = sum_numbers(2)
print(res)
# #函数内部的代码是相同的，只是针对函数不同，处理的结果也不同
# # #当参数满足一个条件时，函数不再执行
#方法4
def sum_numbers(*args):
num = 0
print(args)
# 循环遍历
for n in args:
num += n
return num
result = sum_numbers(1, 2, 3, 4, 5)
print(result)
#方法5
from functools import reduce
res = reduce(lambda x,y:x+y,[1,2,3,4,5],100)
print(res)
# 115
偶数求和
#正常求和
print(sum([1,99])) #100
#方法一
res = 0
i = 0
while i <= 100:
if i % 2 == 0:
print(i)
res += i
i += 1
print("所有偶数和为 = %d" % res)
#方法2
res = 0
for i in range(0,101,2):
res += i
print(res)
#方法3
l =[]
for i in range(1,101):
if i%2 ==0:
l.append(i)
print(sum(l))
元组和字典的拆包
# 在调用多值参数的函数时，如果希望：
# 将一个元组变量直接传递给 args 将一个字典变量直接传递给 kwargs 就可以使用拆包
def demo(*args, **kwargs):
print(args)
print(kwargs)
将一个元组变量\字典变量传递给函数对应函数
gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}
demo(*gl_nums, **gl_xiaoming)
#(1, 2, 3)
#{'name': '小明', 'age': 18}#
石头剪刀布小游戏
import random
player = int(input("输入要出的拳 石头（1）/剪刀(2)/布(3):"))
computer = random.randint(1,3)
print("玩家选择的是%d - 电脑出的是 %d" %(player,computer))
while True:
if ((player == 1 and computer ==2)
or (player == 2 and computer ==3)
or (player == 3 and computer ==4)):
print("win")
break
else:
print("lose")
break
买苹果教程
#需求：收银员输入苹果的价格，单位 元/斤
# 收银员输入用户购买苹果的重量，单位：斤
# 计算价格并输出付款金额
# 1. 输入苹果的单价
price_str = input("苹果的单价：")
# 2. 输入苹果的重量
weight_str = input("苹果的重量：")
# 3. 输入总金额
# money = price_str * weight_str 主要字符串不能相乘 转换成浮点型
price = float(price_str)
weight = format(weight_str)
money = price * weight
print(money)
#加强
price = float(input("苹果的单价："))
weight = float(input("苹果的重量："))
money = price * weight
print(money)
类的使用
#在哪一个对象调用的方法，方法内的self就是哪一个对象的引用
#在类封装方法呢不，self表示当前调用方法的对象自己
#在方法内部。可以通过self访问对象的属性，也可以通过self调用其他的对象方法
class human: #定义一个类：人类
def love(self):
print("%s 爱女人" % self.name)
def hooby(self):
print("还喜欢奶子")
tom = human()
tom.name = "建国"
tom.love()
tom.hooby()
print(tom) #tom的内存地址
jerry = human()
jerry.name = "郭飞"
jerry.love()
jerry.hooby()
# print(jerry)
类的初始化方法加改进
# 使用类名（）创建对象的时候，会自动调用厨是话方法
# 1.为对象在内存中分配空间--创建对象
# 2.为对象的属性设置一个初始值--初始化方法init
# _init_是对象的内置方法，用来定义一个类具有哪些属性的方法
# 在init方法内部使用self.属性名 = 属性的初始值就可以定义属性
# 定义属性后在使用cat类创建的对象，都会拥有这个属性
class Cat:
def __init__(self):
print("这是一个初始化方法")
self.name = "建国"
def eat(self):
print("%s 爱吃肉" % self.name)
jianguo = Cat() # 创建建国猫的对象
print(jianguo.name)
jianguo.eat()
#但是建国名字是固定死的
class Cat:
def __init__(self,new_name): #++++++ （.name）
# print("这是一个初始化方法")
self.name = "建国"
self.name = new_name #++++++++++++++++
def eat(self):
print("%s 爱吃肉" % self.name)
jianguo = Cat("建国") # 创建建国猫的对象
print(jianguo.name)
jianguo.eat()
guofei = Cat("郭飞")
print(guofei.name)
guofei.eat()
面对对象的封装案例
# 小明爱跑步
# ●存放家具
# 01.封装
# 1.封装是面向对象编程的一大特点
# 2.面向对象编程的第一步--将属性和方法封装到一个抽象的类
# 3.外界使用类创建对象,然后让对象调用方法
# 4.对象方法的细节都被封装在类的内部
# 02.小明爱跑步
# 需求
# 小明体重75.0公斤
# 2.小明每次跑步会减肥8.5公斤
# 3.小明每次吃东西体重增加1公斤
class person:
def __init__(self, name, weight):
# self.属性 = 形参
self.name = name
self.weight = weight
def __str__(self):
return "我的名字是%s 体重是 %.2f公斤" % (self.name, self.weight) # .2f表示在输出后保留两位小数
def run(self):
print("%s爱跑步，跑步锻炼身体" % self.name)
self.weight -= 0.5
def eat(self):
print("%s是吃货，吃完这顿在减肥" % self.name)
self.weight += 1
xiaoming = person("小明", 75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
xiaomei = person("小美",45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
# 小明爱跑步，跑步锻炼身体
# 小明是吃货，吃完这顿在减肥
# 我的名字是小明 体重是 75.50公斤
# 小美是吃货，吃完这顿在减肥
# 小美爱跑步，跑步锻炼身体
# 我的名字是小美 体重是 45.50公斤
类的案例：摆放家具*****
# 需求
# 1.房子( House)有户型、总面积和家具名称列表
# ·新房子没有任何的家具
# 2.家具(HouseItem)有 名字 和 占地面积
# 其中
# ·席梦思(bed)占地40平米
# ·衣柜(chest)占地5平米
# ·餐桌(table)占地3平米
# 3.将以上三件家具添加到房子中
# 4.打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表
# 剩余面积
# 在创建房子对象时，定义一个剩余面积的属性，初始值和总面积相当
# 当调用add_item方法，向房间添加家具时，让剩余面积 -= 家具面积
class HouseItem:
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return "[%s]占地 %.2f" %(self.name,self.area)
class House:
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
# 剩余面积
self.free_area = area
# 家具名称列表
self.item_list =[]
def __str__(self):
# Python 能够自动的讲一堆括号内部的代码链接在一起
return ("户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s"
% (self.house_type,self.area,
self.free_area,self.item_list))
# 添加家具的需求: 1.判断家具面积是否超过剩余面积，如果超过，提示不能添加这件家具
# 2.将家具的名称追加到家具名称列表中
# 3.用房子总面积-家具面积=剩余面积
def add_item(self,item):
print("要添加 %s" % item)
#1.判断家具的面积
if item.area > self.free_area:
print("%s的面积太大了，无法添加" % item.name)
return
#2.家具添加列表
self.item_list.append(item.name)
#3.计算剩余面积
self.free_area -= item.area
# 1.创建家具
bed = HouseItem("席梦思",40)
chest = HouseItem("衣柜",5)
table = HouseItem("桌子",3)
print(bed)
print(chest)
print(table)
# 2.创建房子对象
my_home = House("两室一厅",60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)
# 小结：
# 1.创建一个房子类，使用——init——，——str——两个内置方法
# 2.准备了一个 add_item方法准备添加家具
# 3.使用房子类创建一个房子对象 4.让房子对象调用了3次add_item方法，将三件家具以实参传递到 add_item内部
内置模块pi 计算圆的周长和面积
from math import pi
def cicle(radius, mode=0):
def perimiter(radius):
return 2 * pi * radius
def area(radius):
return pi * (radius ** 2)
if mode == 0:
return perimiter(radius)
elif mode == 1:
return area(radius)
res = cicle(5, 0)
print(res)
函数传参
#方案一
def wrapper(x):
print(x)
wrapper(1111)
wrapper(2222)
#方案二：闭包函数
def outter():
x = 111
def wrapper():
print(x)
return wrapper
f = outter()
f()
装饰器不修改参数加功能
优化1
import time # 调用time
def index(x,y,z):
time.sleep(5)
print("index %s %s %s" % (x,y,z))
def wrapper(*args,**kwargs): #加* **是把index写活 解决函数冗余问题
start = time.time()
index(*args,**kwargs)
stop = time.time()
print(stop - start)
wrapper(1111,2222,333)
优化2
import time
def index(x, y, z):
time.sleep(5)
print("index %s %s %s" % (x, y, z))
def outter(func):
# index的内存地址
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs) # index(333,4444,5555)
stop = time.time()
print(stop - start
return wrapper
index = outter(index) # f = outter(index的内存地址)
index(111, 222, 333)
#方案三
import time
def index(x):
time.sleep(5)
print("index %s " % (x))
def outter(func):
# index的内存地址
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
stop = time.time()
print(stop - start)
return res
return wrapper
index = outter(index) # index = outter(index的内存地址)
# index(111)
res = index(666)
print(res)
#index 666
#5.005807638168335
#7777
装饰器模板
# 无参装饰器
import time
def timmer(func):
def wrapper(*args, **kwargs):
# 加需要添加的功能（时间）
#start = time.time()
#time.sleep(2)
res = func(*args, **kwargs)
#stop = time.time()
#print(stop - start)
return res
return wrapper
@timmer
def index():
print("from index")
index()
# 有参装饰器
def outter(x):
def foo(func):
def wrapper(*args, **kwargs):
#添加功能
res = func(*args, **kwargs)
return res
return wrapper
return foo
二层装饰器认证功能
account ={"is_authenticatied" :False, #用户登录了就把这个改成TRUE
"username" :"louyazhou", #存进去的用户信息
"password":"123"
}
def login(func):
def wrraper(*args,**kwargs):
if account["is_authenticated"] is False:
username = input("user:")
password = input("password:")
if username == account["username"] and password == account["password"]:
print("welcome login")
account["is_authenticated"] = True
func(*args,**kwargs)#认证成功 执行代码
else:
print("err")
else:
print("successful")
return wrraper
def home():
print("————首页————")
@login
def america(vip):
if vip > 3:
print("解锁VIP高级玩法")
else:
print("—————欧美专区—————")
@login
def japan(vip):
if vip > 4:
print("解锁日韩全片资源")
else:
print("——————日韩专区——————")
home()
america(4)
japan(5)
#————首页————
user:louyazhou
password:123
welcome login
解锁VIP高级玩法
successful
浙公网安备 33010602011771号