python——复习

木易丫ang

已于 2023-07-03 22:43:38 修改

阅读量43

点赞数

文章标签：数学建模

于 2023-06-02 22:01:51 首次发布

本文链接：https://blog.csdn.net/2303_77327646/article/details/131014744

版权

if 判断

"""
小明期末考试考了95分，学校规定 大于85为优秀，大于70为良好
大于等于60为及格，小于60为差
"""
xiaoming = input('请输入你的成绩：')
if xiaoming > '85':
    print('优')
elif xiaoming > '70':
    print('良')
elif xiaoming  >= '60':
    print('及格')
else :
    print('差')

for 循环 —— 遍历对象或次数时使用

"""
计算 0- 100的奇数和
先定义一个变量
"""
a = 0
for itme in range(1, 101, 2):
    """
    从 1 开始 100 结束，步长为 2 输出为奇数（1,3,5,7,9,11，·····，99）
    【100不包括自身，自身要 +1】
    """
    a += itme  # a 的值 = itme的数值累加
print(f'计算0到100的奇数和等于：{a}')
"""
计算0到100的偶数和
定义一个变量 b
"""
b = 0
for i in range(2, 101, 2):
    """
    偶数以 2 开始 100 结束，步长为 2 输出为（2,4,6,8,10，······，100）
    也可以从 0 开始 100 结束，步长为 2 【100不包括自身，自身要 +1】
    """
    b += i
print(f'计算0到100的偶数和等于：{b}')
"""
计算1到100的整数和
定义一个变量 c
"""
c = 0
for i in range(1, 101):
    """
    从 1 开始 100 结束 【100不包括自身，要 +1】步长默认为 1 可以不写
    """
    c += i  # c 的值等于【1+2+3+4+5+6+·····+100】 i 的值累加
print(f'计算1到100的整数和等于：{c}')

while 循环 —— 根据条件循环时使用

"""
定义一个变量 y
"""
y = 0
while y < 10:
    """
    当 y 的值小于10 时，无限循环
    """
    print(f'循环{y + 1}次')
    """
    当 y 的值累加到 10 时 停止循环
    """
    y += 1
    """
    也可使用 break 终止，停止循环【只循环一次】
    """

函数

"""
def 定义一个函数,调用函数才能拿到函数返回值
"""


def A():
    print('我是函数 a')
    b()  # 在函数 a 中调用函数 b
    """
    在函数内部调用另一个函数叫函数嵌套
    """


def b():
    print('我是嵌套函数 b ')


A()  # 调用函数 A 就可输出函数 a 的值和函数 b 的值





F:\Python3.9\python.exe "D:\muyi\my python\练习.py" 
我是函数 a
我是嵌套函数 b 

Process finished with exit code 0

"""
写一个加法计算器和一个乘法计算器
"""
# 加法计算器
def x (m , b):  # 定义一个函数 m和b为形参
    return m + b  # 返回m+b的值


y = x(10,20)  # 调用函数 输入实参，给个变量接收
print(y)  # 打印输出计算出的值

# 乘法计算器
def h(v , k):
    return v * k


h(4,5)
print(h(4,5))




F:\Python3.9\python.exe "D:\muyi\my python\练习.py" 
30
20

Process finished with exit code 0

闭包

"""
定义一个函数，在函数内部在定义一个函数
当调用函数时，会返回内部函数的值
加（）就是嗲用
"""


def demo(a):  # 定义一个函数 a 为形参
    def func():  # 定义一个内部函数
        return '你好！'+ a  # 内部函数的返回值，也是闭包的返回值
    return func()  # 调用函数，返回内部函数值


print(demo('我是木易'))  # ’我是木易‘为实参 赋予形参 a




F:\Python3.9\python.exe "D:\muyi\my python\练习.py" 
你好！我是木易

Process finished with exit code 0

面向对象

# 面向对象
class Demo():
    # 初始化类属性
    def __init__(self, name, age, sex, color):
        self.name = name  # 名字
        self.age = age  # 年龄
        self.sex = sex  # 性别
        self.color = color  # 肤色
    # 类的方法
    def func(self):
        print(f'我是：{self.name}')
    def func1(self):
        print(f'我今年：{self.age}岁')
    def func2(self):
        print(f'我是：{self.sex}')
    def func3(self):
        print(f'我的肤色是：{self.color}')

# 实例化类
a = Demo('木易',18,'男','黄色')
# 调用方法
a.func()
a.func1()
a.func2()
a.func3()




F:\python\python.exe "D:\muyi\my python\复习.py" 
我是：木易
我今年：18岁
我是：男
我的肤色是：黄色

Process finished with exit code 0

两种写法输出一样这个简洁方便

# 面向对象
class Demo():
    # 初始化类属性
    def __init__(self, name, age, sex, color):
        self.name = name
        self.age = age
        self.sex = sex
        self.color = color

    # 类的方法
    def func(self):
        print(f'我是：{self.name}\n我今年：{self.age}岁\n我是：{self.sex}\n我的肤色是：{self.color}')


# 实例化类
a = Demo('木易', 18, '男', '黄色')
# 调用方法
a.func()




F:\python\python.exe "D:\muyi\my python\复习.py" 
我是：木易
我今年：18岁
我是：男
我的肤色是：黄色

Process finished with exit code 0

写一个面向对象，创建属性和方法，创建多种水果

# 面向对象
class Demo():
    # 初始化类属性
    def __init__(self, name, money, color):
        self.name = name  # 水果名称
        self.money = money  # 水果价钱
        self.color = color  # 水果颜色

    # 类的方法
    def func(self):
        print(f'{self.name}\n{self.money}钱一斤\n这是{self.color}')
        print('·······························')


# 实例化类
a = Demo('苹果', '5块',  '红色的')
# 调用方法
a.func()
# 第二种水果
b = Demo('梨','3块','青皮梨')
b.func()




F:\python\python.exe "D:\muyi\my python\复习.py" 
苹果
5块钱一斤
这是红色的
·······························
梨
3块钱一斤
这是青皮梨
·······························

Process finished with exit code 0

写一个面向对象，创建属性和方法，创建多辆车

# 面向对象
class Demo():
    # 初始化类属性，初始化的形参是可以任意改的
    def __init__(self, x, y, z,t):
        self.name = x  # 名字
        self.money = y  # 价钱
        self.color = z  # 颜色
        self.size = t  # 大小

    # 类的方法
    def func(self):
        print(f'{self.name}\n{self.money}元\n{self.color}\n{self.size}')
        print('·······························')


# 实例化类
a = Demo('奥迪', '1000000',  '红色','B级车')
# 调用方法
a.func()
# 第二辆车
b = Demo('奔驰','6000000','天蓝色','a级车')
b.func()




F:\python\python.exe "D:\muyi\my python\复习.py" 
奥迪
1000000元
红色
B级车
·······························
奔驰
6000000元
天蓝色
a级车
·······························

Process finished with exit code 0

继承

# 面向对象
class Demo():
    # 初始化类属性，初始化的形参是可以任意改的
    def __init__(self, x, y, z, t):
        self.name = x  # 名字
        self.money = y  # 价钱
        self.color = z  # 颜色
        self.size = t  # 大小

    # 类的方法
    def func(self):
        print(f'车名：{self.name}\n车价：{self.money}元\n车的颜色：{self.color}\n车的级别：{self.size}')


# 实例化类
a = Demo('奥迪', '1000000', '红色', 'B级车')
# 调用方法
a.func()


# 第二辆车
class Demo2(Demo):  # Demo2为子类 继承 Demo 父类 的属性
    def func2(self):
        print('加尾翼')  # 给第二辆车加一个尾翼


# 实例化第二辆车
b = Demo2('奔驰', '6000000', '天蓝色', 'a级车')
# 调用第一个方法
b.func()
# 调用第二个方法
b.func2()

F:\python\python.exe "D:\muyi\my python\复习.py" 
车名：奥迪
车价：1000000元
车的颜色：红色
车的级别：B级车
车名：奔驰
车价：6000000元
车的颜色：天蓝色
车的级别：a级车
加尾翼

Process finished with exit code 0

文件管理

open 打开 utf-8 编码

# 创建文件为 text
# 第一个形参 文件名.txt为后缀名，第二形参 权限，encoding 设置格式
a = open('text.txt', 'a+', encoding='utf-8')
# 写入内容
a.write('我写入点内容\n')
# 修改光标，把光标的位置设置为 0
a.seek(0)
# 读取文件里面的内容
print(a.read())




F:\Python3.9\python.exe "D:\muyi\my python\练习.py" 
我写入点内容


Process finished with exit code 0