变量字符串

代码 type() 可以查看数据类型

变量类型转换

num_str = str(11)

print(type(num_str))

运算符

占位符

快捷格式化字符串

表达式格式化

输入input

print("请告诉我你是谁")
name = input()
print(f"我是{name}")

name = input("请告诉我你是谁？")
print(f"我是{name}")

判断

布尔 True表示为真 False表示为假

if语句

age = input("请输入您的年龄")
if int(age) >= 18:
    print("您已成年,请补10元钱")
print("玩的快乐")

age = input("请输入您的年龄")
if int(age) >= 18:
    print("您已成年,请补10元钱")
else:
    print("您未成年 免费")

age = input("请输入您的年龄")
if int(age) >= 18:
    print("您已成年,请补10元钱")
elif int(age) >= 50:
    print("您年纪大 免费")
else:
    print("您未成年 免费")

随机数

import random
num = random.randint(1,10)

随机生成1-10的随机数给num

循环

while循环

i = 0
while i < 100:
    print("小美我喜欢你")
    i += 1

i = 1
while i <= 9:
    j = 1
    while j <= i:
        # /t隔开呢欧容  end= 不换行
        print(f"{j} * {i} = {j * i}\t",end='') 
        j += 1
    i += 1
    print()

for循环

python里for就是遍历循环

range语句

for x in range(10):
    print(x)

加上嵌套

i = 1
for i in range(1,101):
    print(f"今天是表白的第{i}天")
    for j in range(1,11):
        print(f"今天是表白的第{i}天，送的第{j}朵玫瑰")
print(f"表白的第{i}天，成功了")

循环中断

continue关键字用于：中断本次循环，直接进入下次循环 可以控制内循环中断

break关键字用于：直接结束循环 可以加上判断 正确之后直接结束循环

小案例

qian = 8000 
for i in range(1,20):
    import random
    num = random.randint(1,10)
    if qian == 0:
        print("账户余额为0，钱不够了下个月再领取把.")
        break
    if num >= 5:
        qian = qian - 1000
        print(f"员工{i},绩效分{num},发放工资1000元,账户剩余余额{qian}")
    elif num < 5:
        print(f"员工{i},绩效分{num},绩效太低了,不发放工资")

函数

基础

函数是组织好的，可重复使用的，用来实现特定功能的代码段。

len()统计长度的函数

函数：

# 函数
def sat_ho():
    print("nihao")
# 调用
sat_ho()

先定义 后使用

#这是调用参数
def add(num1,num2):
    num3 = num1 + num2
    print(f"两个数字相加是{num3}")
add(18,15)

#加上返回值
def add(num1,num2):
    num3 = num1 + num2
    return num3
print(add(12,15))

return关键词返回~~~~~

返回之后函数后面的命令就不执行了

None类型

思考:如果函数没有使用return语句返回数据，那么函数有返回值吗?实际上是:有的。

Python中有一个特殊的字面量:None，无返回值的函数，实际上就是返回了:None这个字面量

在函数里面的设置 想要用全局变量的话需要加上global这个关键字

global

num4 = 500 
def add(num1,num2):
    global num4
    num4 = 600
    num3 = num1 + num2 + num4
    return num3
print(add(12,15))
print(num4)

小练习

# 初始化用户信息
print("你叫啥名字啊")
name = input()  # 获取用户姓名
yue = 5000000  # 初始账户余额（单位：元）

def chaxun():
    """余额查询功能"""
    print("---------------------余额查询---------------------")
    # 使用f-string格式化输出余额信息
    print(f"{name}, 您好，您的余额剩余：{yue}元\n")

def cunkuan():
    """存款业务处理"""
    global yue  # 声明使用全局变量以修改余额
    
    print("---------------------存款---------------------")
    try:
        # 尝试将用户输入转换为整数（可能引发ValueError）
        cun = int(input("请输入要存的金额："))
        yue += cun  # 更新余额
        
        # 操作结果反馈
        print(f"您存款{cun}元成功")
        print(f"您的余额剩余：{yue}元\n")
    except ValueError:
        # 处理非数字输入异常
        print("错误：请输入有效的数字金额！\n")

def qvkuan():
    """取款业务处理"""
    global yue  # 声明使用全局变量
    
    print("---------------------取款---------------------")
    try:
        qv = int(input("请输入要取的金额："))
        
        # 校验取款金额合法性
        if qv <= 0:
            print("错误：取款金额必须大于0！\n")
            return  # 提前结束函数执行
            
        # 余额充足检查
        if yue >= qv:
            yue -= qv  # 更新余额
            print(f"您取款{qv}元成功")
            print(f"您的余额剩余：{yue}元\n")
        else:
            print("错误：余额不足！\n")
    except ValueError:
        print("错误：请输入有效的数字金额！\n")

# 主程序循环
while True:
    # 打印主菜单界面
    print("---------------------主菜单---------------------")
    print(f"{name}，您好，欢迎来到黑马银行ATM机，请选择操作：")
    print("查询余额\t[输入1]")  # 使用制表符对齐
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    # 获取用户操作选择（可能引发ValueError）
    shuru = int(input("请输入操作编号："))
        
    # 根据输入执行对应操作
    if shuru == 1:
        chaxun()
    elif shuru == 2:
        cunkuan()
    elif shuru == 3:
        qvkuan()
    elif shuru == 4:
        # 退出系统
        print("退出成功，请取回您的银行卡！")
        break  # 跳出循环结束程序
    else:
        # 处理超出范围的数字输入
        print("错误：请输入1-4之间的有效编号！\n")

# 程序结束（循环外）

进阶

多个返回值

def duogefanhuizhi():
    return 1,2,3
x,y,z = duogefanhuizhi()
print(x)
print(y)
print(z)

多个传参种类

可变参数

以上穿元组 之类的 通过单个*来传送

以上传送字典 通过两个**来传送

函数串函数

lambda匿名函数

数据容器

list类型

索引

列表的操作方法

查找某元素的下标 .index(元素)

list.index(元素)

修改特定信标索引值的修改方法

list[1] = "新数据“

插入元素 .insert(下标，元素 )

list.insert(下标，元素 ) （后面的往后拍）

追加元素到尾部 .append(元素)

list.append(元素)

追加一批元素 （追加到最后）.extend(其他数据容器)

list.extend(其他数据容器) （比如 list.extend(list2)）

删除元素的语法

1. del list[1] (这就删除了1下标的)

2. list.pop(下表) （取出这个元素 能打印出来 也相当于删除了）

删除某元素在列表中的第一个匹配项 .remove(元素)

list.remove(元素) （比如 list.remove(liyus)）

清空整个列表 .clear()

list.clear()

统计某个元素在列表中的数量 .count(元素)

list.count(元素)

统计列表中全部元素

len(列表)

遍历列表

while循环

my_list = [1,2,3,4,5]
i = 0
while i < len(my_list):
    yuansu = my_list[i]
    print(f"列表的元素：{yuansu}")
    i += 1

for循环

my_list = [1,2,3,4,5]
for i in my_list:
    print(f"您的元素是:{i}")

元组tuple()

元组的信息是不可以修改，也是可以存储多个不同类型的元素 相当于只读的list。

元组使用小括号定义 tuple()

# 创建方式
t1 = (1,2,3,4,5)
t2 = ()
t3 = tuple() 
t4 = ("hello",) # 元组只放一个元素的话 最后面需要带，

查找某元素的下标 .index(元素)

tuple.index(元素)

统计某个元素在列表中的数量 .count(元素)

tuple.count(元素)

统计元组中全部元素

len(元组)

字符串str

字符串是不可修改的 要改的话 只能创建一个新的字符串

str.index方法 查找 查找起始西南表

字符串的替换.replace

str.replace(str1，str2)（把str1全部删掉 换成str2）这个方法是生产一个新的字符串

str1 = "SDASCCCWE"
str2 = str1.replace("SD","DS")
print(str1)
print(str2)

字符串的分割.split

str.split（是通过切分符来进行切分的）分割成一小段段字符串存到列表中

去除前后空格.strip()

str.strip()

如果传入字符串 那就是去除前后字符串

统计字符串count = str("it")

统计it在str字符串里面的次数

统计字符串长度len(str)

序列

切片

切片不会影响老切片 会生成新切片

my_list = [1,2,3,4,5,6]
my_list2 = my_list[1:4]
print(my_list2)    # 打印为 [2, 3, 4] 

上述操作结束 截取my_list里面的下标从1-4(不包含4)

my_tuple = (1,2,3,4,5,6)
my_tuple2 = my_tuple[1:4]
print(my_tuple2) # 打印为 [2, 3, 4] 

上述操作结束 截取my_tuple里面的下标从1-4(不包含4)

my_str = "123456"
my_str2 = my_str[1:4]
print(my_str2) # 打印为234

上述操作结束 截取my_str里面的下标从1-4(不包含4)

以上都没加步长 加上步长为

my_str = "123456"
my_str2 = my_str[0:4:2]
print(my_str2) # 打印为 13

加上步长了 为2 每在0 - 4 里面 每两步取一下

my_str = "123456"
my_str2 = my_str[::-1]
print(my_str2) #打印为654321

这个操作相当于把序列反转了(倒叙)

set集合

集合用大括号{}

集合最大特点就是无序，不重复。下标索引就没法用了

set = {1，2，3，4}

字典

无下标索引

my_dict = {"王力宏":99,"王2宏":97} # 新建了一个字典
print(my_dict["王力宏"]) # 这样就找到了王力宏的考试分数

my_dict2 = {
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":33
    },"周杰军":{
        "语文":88,
        "数学":86,
        "英语":55
    }
} 
print(my_dict2["周杰军"]["语文"]) 

嵌套字典 以及取嵌套字典的方法

小案例

my_dict = {
    "王力宏":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },"周杰军":{
        "部门":"市场部",
        "工资":5000,
        "级别":2
    },"林俊杰":{
        "部门":"科技部",
        "工资":4000,
        "级别":1
    } 
}
key = ["王力宏","周杰军","林俊杰"]
for key in my_dict:
    if my_dict[key]["级别"] == 1:
        my_dict[key]["级别"] += 1
        my_dict[key]["工资"] += 1000

print(my_dict)

数据容器的分类

通用操作

python的文件

用UTF-8

打开文件

f = open("D:/ml.txt","r",encoding="UTF-8") # 打开文件

读操作相关

f.read() # 读取全部内容
f.readlines() # 读取全部对象行，封装到列表中

一行一行读取

line1 = f.readline() #读取第一行

line2 = f.readline() #读取第二行

line3 = f.readline() #读取第三行

for循环读取每一行

for line in f:
    print(f"每一行数据是{line}")

文件关闭

close()关闭文件

f.close()   # 关闭文件

下面是打开关闭等等

with open("D:/ml.txt","r",encoding="UTF-8") as f:
    print(f.read())

文件的写入

文件写入.write()

with open("D:/mcw.txt","a",encoding="UTF-8") as f: # 这样 a 是追加写入
    f.write("cwc")
    f.flush()

内容刷新.flush()

换行符 \n

with open("D:/mcw.txt","a",encoding="UTF-8") as f: # 这样 a 是追加写入
    f.write("\ncwc") # 此处导入换行了
    f.flush()

小案例

# 打开文件得到文件对象，准备读取
fr = open("D:/bill.txt", "r", encoding="UTF-8")
# 打开文件得到文件对象，准备写入
fw = open("D:/bill.txt.bak", "w", encoding="UTF-8")
# for循环读取文件
for line in fr:
    line = line.strip()
    # 判断内容，将满足的内容写出
    if line.split(",")[4] == "测试":
        continue        # continue进入下一次循环，这一次后面的内容就跳过了
    # 将内容写出去
    fw.write(line)
    # 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
    fw.write("\n")

# close2个文件对象
fr.close()
fw.close()      # 写出文件调用close()会自动flush()

python异常

捕获异常

try:
    f = open ("D:/abc.txt","r",encoding="UTF-8")
except:
    print("asddasdas")

捕获指定异常

try:
    print(Name)
except NameError as e:
   print("出现了变量未定义的异常")

捕获多个异常

try:
    print(Name)
    1 / 0 
except (NameError,ZeroDivisionError) as e:
   print("出现了多个异常")
   print(e)

捕获所有异常

try:
    print(Name)
except :
   print("出现异常了")


try:
    1 / 0 
except Exception:
   print("出现异常了")

else：没有异常

try:
    print("lalala")
except :
   print("出现异常了")
else : 
    print("没有异常")

有没有异常都去执行finally:

try:
    print("lalala")
except :
   print("出现异常了")
else : 
    print("没有异常")
finally:
    print("我最6")

try:
    1 / 0 
except Exception:
   print("出现异常了")
finally:
    print("我最6")

模块

import time #导入python内置的time模块（time.py这个代码文件）
print("你好")
time.sleep(5) #通过.就能使用模块内部的全部功能
print("我好")

# 使用from导入time的sleep功能（函数）  （这个方法只能用time里面的 sleep功能）
from time import sleep
print("你好")
sleep(5)
print("我好")

# 使用 * 导入time模块的全部功能
from time import *      # *表示全部的意思
print("你好")
sleep(5)
print("我好")

# 使用as给特定功能加上别名
import time as t
print("你好")
t.sleep(5)
print("我好")

from time import sleep as sl # 把time.sleep 改成 sl这个别名
print("你好")
sl(5)
print("我好")

自定义模块

if __name__ == '__main__': #这个内部就是main方法
                           #是测试模块

python包

# 创建一个包
# 导入自定义的包中的模块，并使用
import my_package.my_module1
import my_package.my_module2
#
my_package.my_module1.info_print1() #把包 模块 函数导入本地
my_package.my_module2.info_print2()

from my_package import my_module1
from my_package import my_module2
my_module1.info_print1()
my_module2.info_print2()

from my_package.my_module1 import info_print1
from my_package.my_module2 import info_print2
info_print1()
info_print2()

# 通过__all__变量，控制import *
from my_package import *
my_module1.info_print1()
my_module2.info_print2()

安装第三方包

在cmd 管理员里面输入 pip install 包的名字 就可以安装第三方包

PS C:\Users\yc242> pip install numpy

面向对象~！~！~！~！

设计类 (class)

# 设计一个类
class Student:
    name = None     # 记录学生姓名
    gender = None   # 记录学生性别
    age = None      # 记录学生年龄
# 创建一个对象
stu_1 = Student()
# 对象属性进行赋值
stu_1.name = "林俊杰"
stu_1.gender = "男"
stu_1.age = 18
# 获取对象中的记录的信息
print(stu_1.name,stu_1.gender,stu_1.age)

成员变量和方法

成员方法中使用成员变量 需要用self这个函数

# 设计一个类
class Student:
    name = None     # 记录学生姓名
    gender = None   # 记录学生性别
    age = None      # 记录学生年龄

    def say_hi(self):
        print(f"大家好我是{self.name},请大家多多关照")
    def say_hi1(self,msg):  # 传入就self就当不存在进行  只会对msg进行传入
        print(f"大家好我是{self.name},{msg}")
stu1 = Student()
stu1.name = "林俊杰"
stu1.gender = "男"
stu1.age = 18
print(stu1.say_hi())
print(stu1.say_hi1("哎呦不错呀"))

类和对象

# 设计一个闹钟类
class Clock:
    id = None       # 序列化
    price = None    # 价格


    def ring(self):
        import winsound
        winsound.Beep(2000, 3000)

# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003032"
clock1.price = 19.99
print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
# clock1.ring()

clock2 = Clock()
clock2.id = "003033"
clock2.price = 21.99
print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
clock2.ring()

构造方法

# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称：__init__

class Student:

    def __init__(self, name, age ,tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")

stu = Student("周杰轮", 31, "18500006666")
print(stu.name)
print(stu.age)
print(stu.tel)

魔术方法

class Student:
    def __init__(self, name, age):
        self.name = name        # 学生姓名
        self.age = age          # 学生年龄

    # __str__魔术方法
    def __str__(self):   # 字符串返回信息
        return f"Student类对象,name:{self.name}, age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):    # 比较两个对象 的大小  ，比如这个是对比两个年龄的对比  <>
        return self.age < other.age

    # __le__魔术方法
    def __le__(self, other):    # 和上面的一样 就是可以小于等于的对比   <= >=
        return self.age <= other.age

    # __eq__魔术方法
    def __eq__(self, other):    # 和上面的一样 就是可以查看两个数的年纪是不是相等   ==
       return self.age == other.age


stu1 = Student("周杰轮", 31)
stu2 = Student("林俊节", 36)
print(stu1)
print(stu1  > stu2)
print(stu1  < stu2)

前面两个 后面两个下划线 魔术方法

封装

# 定义一个类，内含私有成员变量和私有成员方法
class Phone:
    __current_voltage = 0.5        # 当前手机运行电压


    def __keep_single_core(self):
        print("让CPU以单核模式运行")


    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")


phone = Phone()
phone.call_by_5g()

私有成员 能被同一类其他成员使用

继承

# 演示单继承
class Phone:
    IMEI = None     # 序列号
    producer = "ITCAST" # 厂商


    def call_by_4g(self):
        print("4g通话")


class Phone2022(Phone):
    face_id = "10001"       # 面部识别ID


    def call_by_5g(self):
        print("2022年新功能：5g通话")


phone = Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()
# 演示多继承          多继承真优雅
class NFCReader:
    nfc_type = "第五代"
    producer = "HM"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")


class RemoteControl:
    rc_type = "红外遥控"

    def control(self):
        print("红外遥控开启了")


class MyPhone(Phone, NFCReader, RemoteControl):    # 直接pass  # 输出统一成员属性的话话 就是从左往右
    pass


phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

多继承 真优雅

pass 关键字就是用来补全语法的 表示这里是空的 不产生错误

复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写即:在子类中重新定义同名的属性或方法即可。

class Phone:
    IMEI = None             # 序列号
    producer = "ITCAST"     # 厂商

    def call_by_5g(self):
        print("使用5g网络进行通话")


# 定义子类，复写父类成员
class MyPhone(Phone):
    producer = "ITHEIMA"        # 复写父类的成员属性

    def call_by_5g(self):
        print("开启CPU单核模式，确保通话的时候省电")
        # 方式1
        # print(f"父类的厂商是：{Phone.producer}")
        # Phone.call_by_5g(self)
        # 方式2
        print(f"父类的厂商是：{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式，确保性能")

phone = MyPhone()
phone.call_by_5g()
print(phone.producer)

类型注解

# 基础数据类型注解
import json
import random

# var_1: int = 10
# var_2: str = "itheima"
# var_3: bool = True
# 类对象类型注解
class Student:
    pass
stu: Student = Student()

# 基础容器类型注解
# my_list: list = [1, 2, 3]
# my_tuple: tuple = (1, 2, 3)
# my_dict: dict = {"itheima": 666}
# 容器类型详细注解
my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, "itheima", True)
my_dict: dict[str, int] = {"itheima": 666}
# 在注释中进行类型注解
var_1 = random.randint(1, 10)   # type: int
var_2 = json.loads('{"name": "zhangsan"}')  # type: dict[str, str]
def func():
    return 10
var_3 = func()  # type: int
# 类型注解的限制
var_4: int = "itheima"
var_5: str = 123

"""
演示对函数（方法）进行类型注解
"""

# 对形参进行类型注解
def add(x: int, y: int):
    return x + y

# 对返回值进行类型注解
def func(data: list) -> list:
    return data

print(func(1))

Union类型

"""
演示Union联合类型注解
"""
# 使用Union类型，必须先导包
from typing import Union

my_list: list[Union[int, str]] = [1, 2, "itheima", "itcast"]

def func(data: Union[int, str]) -> Union[int, str]:
    pass

多态

# 演示面向对象的多态特性以及抽象类（接口）的使用

# 定义一个基类 Animal，它是一个抽象类，因为它的方法 speak() 没有具体实现
class Animal:
    def speak(self):
        pass  # 父类中的方法没有具体实现，子类需要重写该方法

# 定义 Dog 类，继承自 Animal 类
class Dog(Animal):
    def speak(self):
        print("汪汪汪")  # 狗叫的方法实现

# 定义 Cat 类，继承自 Animal 类
class Cat(Animal):
    def speak(self):
        print("喵喵喵")  # 猫叫的方法实现

# 定义一个函数 make_noise，接收一个 Animal 类型的对象作为参数
def make_noise(animal: Animal):
    """制造点噪音，需要传入Animal对象"""
    animal.speak()  # 调用传入对象的 speak 方法

# 演示多态，使用 2 个子类对象来调用函数
dog = Dog()  # 创建 Dog 对象
cat = Cat()  # 创建 Cat 对象

make_noise(dog)  # 传入 Dog 对象，调用 Dog 的 speak 方法，输出 "汪汪汪"
make_noise(cat)  # 传入 Cat 对象，调用 Cat 的 speak 方法，输出 "喵喵喵"

# 演示抽象类
# 定义一个抽象类 AC，它定义了空调的一些基本功能，但没有具体实现
class AC:
    def cool_wind(self):
        """制冷"""
        pass  # 父类中的方法没有具体实现，子类需要重写该方法

    def hot_wind(self):
        """制热"""
        pass  # 父类中的方法没有具体实现，子类需要重写该方法

    def swing_l_r(self):
        """左右摆风"""
        pass  # 父类中的方法没有具体实现，子类需要重写该方法

# 定义 Midea_AC 类，继承自 AC 类，实现了 AC 的所有方法
class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")  # 美的空调制冷功能实现

    def hot_wind(self):
        print("美的空调制热")  # 美的空调制热功能实现

    def swing_l_r(self):
        print("美的空调左右摆风")  # 美的空调左右摆风功能实现

# 定义 GREE_AC 类，继承自 AC 类，实现了 AC 的所有方法
class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")  # 格力空调制冷功能实现

    def hot_wind(self):
        print("格力空调制热")  # 格力空调制热功能实现

    def swing_l_r(self):
        print("格力空调左右摆风")  # 格力空调左右摆风功能实现

# 定义一个函数 make_cool，接收一个 AC 类型的对象作为参数
def make_cool(ac: AC):
    ac.cool_wind()  # 调用传入对象的 cool_wind 方法

# 创建 Midea_AC 和 GREE_AC 对象
midea_ac = Midea_AC()
gree_ac = GREE_AC()

# 调用 make_cool 函数，传入不同的空调对象，实现多态
make_cool(midea_ac)  # 传入美的空调对象，输出 "美的空调制冷"
make_cool(gree_ac)  # 传入格力空调对象，输出 "格力空调制冷"