零基础学python

于 2023-12-13 19:59:20 发布
阅读量45 收藏
点赞数 1
文章标签： python 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d111_44/article/details/134980651
版权

输出

print("hello word")

hello word

输入

print("请输入两个数字，用回车分隔")
​
​
​
​
number_max=10
number1=input()
number2=input()
result =number_max+int(number1)+int(number2)
print(result)#结果  =字符

请输入两个数字，用回车分隔

2 2 14

-----------标识符----------

1.不能数字开头

2.严格区分大小写

3.不能关键字命名

4.不能特殊字符开头

--------------标识符下划线开头-------------------

-------缩进1-------
flag=True
if flag:
 print("true")
else:
 print("False")
print("hello")

true hello

-------缩进2-------
flag=True
if flag:
 print("true")
else:
 print("False")
 print("hello")

true

--------注释------------

快捷键 ：ctrl+?

用法：1.#开头 单行注释

2.三个单引号或三个双引号

---------------常量，变量-----------------

常量：固定的类型 命名：全部大写

变量：存储数据，可更改

-----------------数据类型--------------

1.整型 int :整数

2.浮点型 float:包含小数

3.布尔型 bool：两个值 0/1=true or false

4.复数型complex：实数和虚数 复数类型

5.字符串型 string：用单引号，双引号，三引号或三双引号作为定界符括起来的字符序列

6.列表 list:

print("hello")
list_1 = [1,2,3,4,5,6,7]
print(list_1)
#type()
print(type(list_1))

[1, 2, 3, 4, 5, 6, 7] <class 'list'>

特点：（1）大小可变的序列类型

（2）元素类型

tuple:元组不可变，列表可变，因此元组可以作为字典的键，列表不行。

a=[1,2,3]
​
a[0]=10
​
print(a)

[10, 2, 3]

进程已结束，退出代码为 0

7.字典：元素以键：值对形式出现

class1_student_name = \
    {
        202201:"张三1",
        202202: "张三2",
        202203: "张三2"
    }
print(class1_student_name[202201])

张三1

进程已结束，退出代码为 0

8.集合set：一个集合可以有多个元素（元素不能重复），元素必须是不可变的数据类型 例如： “ []不行” “字典不行”

set_1 = {1,2,3,(1,2,3)}
print(type(set_1))
print(set_1)

<class 'set'> {1, 2, 3}

进程已结束，退出代码为 0

------------------运算符--------------------

1.算数运算符：+，-，*（乘），/（除），%（得余数），**(幂返回y的x次幂)，//（只取整数部分，不是四舍五入）

2.赋值运算符：+=（c+=a等效于c=c+a）.......

3.比较运算符:>=大于,<=小于，==赋值，！=不等于

4.逻辑运算符：and和 左右两边同时满足，返回值，or或 左右两边满意一个就可返回，not否定非

5.位运算符

例如：与运算：a 60二进制：00111100； b 13二进制：00001101 ;&--------00001100 so print (bin (a&b)):0b1100

位运算：a 60二进制：00111100； b 13二进制：00001101 ;|--------00111101 so print( bin(a|b)):0b111101

6.身份运算符

7.成员运算符：in ;not in

list1 = [1,2,3,4,5,6,7,8,9,10]
if(5 in list1):
    print("有这个元素")
else:
    print("没有这个元素")

有这个元素

进程已结束，退出代码为 0

---------------------------------区别------------------------：

is 判断两个变量是否指向同一个对象，地址是否相同，可以通过id()函数判断；

== 判断两个变量的值是否相等；

is not 判断的是两个变量是否指向不同的对象；

！= 判断两个变量的值是否不相等；

总结：is ；is not 对比的是两个变量的内存地址

== ；！= 对比的是两个变量的值

----------------------运算符优先级---------------------

----1.华氏温度转为摄氏温度公式：c=(f-32)/1.8------

代码：

TempStr = input("请输入带有符号的温度值")
for  i   in range(1):  # 此处为循环次数，可自由设置
        val = input("请输入带温度标识符号的温度值（例如26C）:")
        if val[-1] in ['C', 'c']:  # 判断是否为摄氏温度
            f = 1.8 * float(val[0:-1]) + 32
            print("转换后的温度为:%.2fF" % f)
        elif val[-1] in ['F', 'f']:  # 判断是否为华氏温度
            c = (float(val[0:-1]) - 32) / 1.8
            print("转换后的温度为:%.2fC" % c)
        else:
            print("输入的温度格式有误，请重新输入")

请输入带有符号的温度值c 请输入带温度标识符号的温度值（例如26C）:26c 转换后的温度为:78.80F

print("请输入华氏温度")
F = float(input())
c = (F - 32) / 1.8
result = c
print(result)

请输入华氏温度 26 -3.333333333333333

进程已结束，退出代码为 0

-----2.圆的半径计算周长和面积。--------

分析：

周长 c=2Πr=Πd(Π为半径，d为直径)

面积s=Πr

代码：

"""
功能： 输入圆半径，计算圆周长和面积
作者： Fulling
时间： 2021年10月15日
"""

import math

# 输入部分
r = float(input('输入圆的半径：'))

# 处理部分
c = 2 * math.pi * r
s = math.pi * r ** 2

# 输出部分
print('该圆的周长是：%.2f' % c)
print('该圆的面积是：%.2f' % s)

输入圆的半径：5 该圆的周长是：31.42 该圆的面积是：78.54

-----------------3.输入年份判断是不是闰年。--------------------------

分析：

结合逻辑运算符来判断，用户输入一个年份，判断这个年份是不是闰年\n世纪年：能被400整除的才是闰年（能被100整除的才是世纪年）year%400= =0\n普通年：能被4整除的才是闰年 year%100!=0 year%4==0

总结：1.非整百年份：能被4整除的是闰年。（如2004年就是闰年，2001年不是闰年）

2.整百年份：能被400整除的是闰年。（如2000年是闰年，1900年不是闰年）

3.对于数值很大的年份：如果这一年能被3200整除，那么这一年不是闰年，但如果这一年能被172800整除，则为闰年。

代码：

year = int(input("输入一个年份：")) if (year % 4) == 0: if (year % 100) == 0: if (year % 400) == 0: print("{0} 是闰年".format(year)) else: print("{0} 不是闰年".format(year)) else: print("{0} 是闰年".format(year)) else: print("{0} 不是闰年".format(year))

等同于=

year = int(input("请输入一个年份："))
if (year % 4) == 0 and (year % 100) != 0 or (year % 400) == 0:
    print("{0}是闰年".format(year))
else:
    print("{0}不是闰年".format(year))

请输入一个年份：2004 2004是闰年

进程已结束，退出代码为 0

--------------------字符串----------------------

字符串格式化输出：

print(' % d. 我是%s ! ' % (1,'英雄联盟'))

print(' % d. 我是%s ! ' % (4,'开心消消乐'))

print("% d, 我是%s ! " % (1,'开心  消消乐'))

print("我是%s的%s,学号是%d" %("一班","红",202201))

  1. 我是英雄联盟 !

    4.我是开心消消乐 ! 1, 我是开心 消消乐 ! 我是一班的红,学号是202201

进程已结束，退出代码为 0

------------------字符串内建函数------------------

1.字符串的第一个字符大写

str="i\'m good student"
print(str.capitalize())

I'm good student

进程已结束，退出代码为 0

标题大写

str="i\'m good student"
print(str.title())

I'M Good Student

2.

upper():字符串中全部大写

lower():字符串中全部小写

str="i\'m good student"
print(str.upper())
print(str.lower())

I'M GOOD STUDENT i'm good student

进程已结束，退出代码为 0

3.居中对齐：center

左对齐：ljust

右对齐：rjust

print('{:^10}'.format('LOL'))
print("lol".center(10,))
print('{:<10}'.format('LOL'))
print("lol".ljust(10,))
print('{:>10}'.format('LOL'))
print("lol".rjust(10,))
print('{:$<10}'.format('LOL'))
print("lol".ljust(10,"$"))
print('{:*>10}'.format('LOL'))
print("lol".rjust(10,"*"))
print('{:*^11}'.format('LOL'))
print("lol".center(11,"*"))

LOL lol LOL lol LOL lol LOL$$$$$$$ lol$$$$$$$ ***LOL ***lol LOL lol

进程已结束，退出代码为 0

3.截取字符串左右的空格或指定字符

左边：lstrip

右边:rstrip

删除一句所有指定字符：replace

str ="****AAA***BBB******"
print(str.strip("*"))
print(str.lstrip("*"))
print(str.rsplit("*"))
print(str.replace("*",""))

AAABBB AAABBB** ['', '', '', '', 'AAA', '', '', 'BBB', '', '', '', '', '', ''] AAABBB

进程已结束，退出代码为 0

4.

max()

min()

import string
str = string.ascii_lowercase
print(str)
print(max(str))#实际比较的是ascill码
print(max("aAzZ"))
print(max("比较中文"))
print(min("比较中文"))

abcdefghijklmnopqrstuvwxyz z z 较 中

进程已结束，退出代码为 0

5.

str="this is string example...WOW!!!"
print(str.split())  #默认空格为分隔符
print(str.split('i',1))#以i为分隔符
print(str.split('W'))#以w为分隔符



str1 ="20201-dqh"
str2 ="20201+dqh"
str3 ="20201 dqh"
print(str1.split("-"))
print(str2.split("+"))
print(str3.split(" "))

['this', 'is', 'string', 'example...WOW!!!'] ['th', 's is string example...WOW!!!'] ['this is string example...', 'O', '!!!'] ['20201', 'dqh'] ['20201', 'dqh'] ['20201', 'dqh']

进程已结束，退出代码为 0

6.

str="计应2班-xxx"
print(str.startswith("计应2班"))

True

进程已结束，退出代码为 0

7.

str2="abcABC"
print(str2.swapcase())#swapcase交换

ABCabc

进程已结束，退出代码为 0

加密解密：

table1 ="abcdfghijklmnopqrstuvwxyz"
table2 = table1[1:] + table1[0:1]
data = "dear sweet,i love you"
table = str.maketrans(table2,table1)
print("加密后的明文：%s"%(data.translate(table)))

#cdzq rvdds ,h knud xnt
table1 ="abcdfghijklmnopqrstuvwxyz"
table2 = table1[1:] + table1[0:1]
#改输入
data = "cezq rvees,h knue xnt"
#改映射顺序
#table = str.maketrans(table2,table1)
table = str.maketrans(table1,table2)
print("解密后的明文：%s"%(data.translate(table)))

加密后的明文：cezq rvees,h knue xnt 解密后的明文：dear sweet,i love you

-------------走马灯-------------

import  os
import  time
# content ='北京欢迎你 为你开天辟地'
# content ='我爱祖国 我爱学习'
content ="欢迎报考本校"
while True:
    #windows清除屏幕上的输出
    #os.system('cls')
    #macos 清除屏幕上的输出
    os.system('cls')
    print(content)
    #休眠0.2秒（200毫秒）
    time.sleep(0.2)
    content = content[1:] +content[0]

欢迎报考本校

-------------------------------密码强度等级--------------------

import string

pwd = input()
def check(pwd):
    #密码必须至少六位数
    if len(pwd)< 6:
        return "weak"
    #密码强度等级与包含字符种类的对应关系
    d = {1:"weak",2:"below middle",3:"above middle",4:"strong",}
    #分别用来标记pwd是否含有数字、小写字母、大写字符和指定的标点符号
    r = [False]*4
    #等价于r = [True,False,False,False]

    for ch in pwd:
        #是否包含数字
        #if not r[0] and ch in string.digits:
        if not r[0] and ch in "123456789":
            r[0] = True
        #是否包含小写字母
        elif not r[1] and ch in string.ascii_lowercase:
            r[1] = True
        #是否包含大写字母
        elif not r[2] and ch in string.ascii_uppercase:
            r[2] = True
        #是否包含指定的标点符号
        elif not r[3] and ch in ",.;'[]\!@#$%^&*()_+":
            r[3] = True
    #统计包含的字符种类，返回密码强度
    return d.get(r.count(True),"error")
print(check(pwd))

12 weak

-------------------------------文件后缀--------------------------------

def get_suffix(filename):
    '''
    获取文件名的后缀名
    ：param filename：文件名
    ：return：文件的后缀名
    '''
    # 从字符串中逆向查找.出现的位置
    pos = filename.rfind('.')
    # 通过切片操作从文件名中取出后缀名
    # return filenamee[pos + 1:] if pos > else ''
    if pos > 0:
        return filename[pos + 1:]
    else:
        return ''

# 可以用下面的代码对上面的函数做一个简单的测试。
print(get_suffix('readme.txt'))
print(get_suffix('readme.txt.md'))
print(get_suffix('.readme'))
print(get_suffix('readme.'))
print(get_suffix('readme'))

txt md

进程已结束，退出代码为 0

name ="dqh"
a=1
b=2
print(f'我的名字叫{name},我是聪明，我会算{a}+{b}={a+b}')

我的名字叫dqh,我是聪明，我会算1+2=3

进程已结束，退出代码为 0

print(f"{a+b=}")

a+b=3

进程已结束，退出代码为 0

---------if条件语句--------------------

1.语法

2.缩进

s=" "
#if +条件 +：
#条件为真的语句
if s !='':
    print(s)
    #else否则:---else后面不能加条件
else:
    print(s+"***")
numbers1=7
if numbers1 ==1:
    print("1")
elif numbers1 ==2:
     print("2")
elif numbers1 ==3:
    print("3")
elif numbers1 ==4:
    print("4")
elif numbers1 == 5:
    print("5")
elif numbers1 == 6:
    print("6")
else:
    print("没找到")

没找到

进程已结束，退出代码为 0

周期性输出（反复循环）

while true:

嵌套while循环

while True:
    a=0
    while a<10:
        print(a)
        a=a+1

反复循环0-9

for 循环

1-100求和：

a=0
for i in range(1,101):
    a=i+a
    print(a)

1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496 528 561 595 630 666 703 741 780 820 861 903 946 990 1035 1081 1128 1176 1225 1275 1326 1378 1431 1485 1540 1596 1653 1711 1770 1830 1891 1953 2016 2080 2145 2211 2278 2346 2415 2485 2556 2628 2701 2775 2850 2926 3003 3081 3160 3240 3321 3403 3486 3570 3655 3741 3828 3916 4005 4095 4186 4278 4371 4465 4560 4656 4753 4851 4950 5050

进程已结束，退出代码为 0

1-100偶数求和：
a=1
for i in range(2,101,2):
    a=i+a
    print(a)

2 6 12 20 30 42 56 72 90 110 132 156 182 210 240 272 306 342 380 420 462 506 552 600 650 702 756 812 870 930 992 1056 1122 1190 1260 1332 1406 1482 1560 1640 1722 1806 1892 1980 2070 2162 2256 2352 2450 2550

进程已结束，退出代码为 0

打印乘法口诀表：
for  i in range(1,10):
    for j in range(1,i+1):
        print(f'{i}*{j}={i * j}',end='\t')
    print("")

11=1 21=2 22=4 31=3 32=6 33=9 41=4 42=8 43=12 44=16 51=5 52=10 53=15 54=20 55=25 61=6 62=12 63=18 64=24 65=30 66=36 71=7 72=14 73=21 74=28 75=35 76=42 77=49 81=8 82=16 83=24 84=32 85=40 86=48 87=56 88=64 91=9 92=18 93=27 94=36 95=45 96=54 97=63 98=72 9*9=81

进程已结束，退出代码为 0

遍历时，跳过p,继续输出后面字符

s= 'I love python'
for i in s:
    if i == "p":
        break
        print('当前遍历的字母：',i)
print('遍历结束')

s= 'I love python'
for i in s:
    if i == "p":
        continue
        print('当前遍历的字母：',i)
print('遍历结束')

s= 'I love python'
for i in s:
    if i == "p":
        pass
        print('当前遍历的字母：',i)
print('遍历结束')

第六章函数

递归：函数运行时不断调用自己

保护属性：__

1.静态方法在什么时候使用

静态方法通常用于与类本身或类实例无关的公共方法。这些方法不需要访问实例变量或实例方法，只依赖于类变量和类方法。

静态方法的主要用途包括：

  1. 工具方法：不依赖于实例状态的方法，如计算器类中的加法、减法等方法。

  2. 数据访问方法：访问静态数据的方法，如访问类的属性或静态变量。

  3. 类级别的操作方法：对类进行操作的方法，如将类转换为字符串表示或执行类级别的初始化操作。

以下是一个简单的示例：

class MyClass:
    static_var = 0

    @staticmethod
    def static_method():
        print("这是静态方法")

    @classmethod
    def class_method(cls):
        print("这是类方法")

    def instance_method(self):
        print("这是实例方法")

# 静态方法
MyClass.static_method()  # 输出：这是静态方法

# 类方法
MyClass.class_method()  # 输出：这是类方法

# 实例方法
obj = MyClass()
obj.instance_method()  # 输出：这是实例方法

在这个示例中，static_method和class_method都是类方法，但它们定义的方式不同。static_method使用staticmethod装饰器，class_method使用classmethod装饰器。静态方法可以直接通过类名调用，类方法需要通过类名和类实例调用。

2.静态方法和类方法的区别

静态方法和类方法是面向对象编程中两个不同类型的方法，它们在定义和使用上有一些区别。

  1. 定义方式： 静态方法是在类中使用static关键字定义的，它属于类，而不是类的实例。类方法是在类中使用classmethod关键字定义的，它属于类，但可以被类实例调用。

  2. 调用方式： 静态方法可以直接通过类名调用，如ClassName.static_method()。类方法可以通过类名和类实例调用，如ClassName(instance_arguments).class_method()。

  3. 访问方式： 静态方法属于类，只能访问类变量和类方法，不能访问实例变量和实例方法。类方法属于类，可以访问类变量、类方法和实例变量，但不能访问实例方法。

下面是一个简单的示例：

class MyClass:
    static_var = 0

    @staticmethod
    def static_method():
        print("这是静态方法")

    @classmethod
    def class_method(cls):
        print("这是类方法")

# 静态方法
MyClass.static_method()  # 输出：这是静态方法

# 类方法
MyClass.class_method()  # 输出：这是类方法

# 实例调用类方法
obj = MyClass()
obj.class_method()  # 输出：这是类方法

在这个示例中，static_method和class_method都是类方法，但它们定义的方式不同。static_method使用staticmethod装饰器，class_method使用classmethod装饰器。静态方法可以直接通过类名调用，类方法需要通过类名和类实例调用。

3.私有变量在什么时候用

私有变量通常用于封装类的内部状态，防止外部直接访问。它们可以用于以下场景：

  1. 数据封装：将类的属性封装为私有变量，防止外部直接访问。

  2. 数据保护：防止外部修改私有数据，确保数据的完整性和安全性。

  3. 实现细节：将类的实现细节封装为私有变量，防止外部直接了解和修改。

以下是一个简单的示例：

class MyClass:
    def __init__(self, value):
        self.__value = value

    def get_value(self):
        return self.__value

    def set_value(self, value):
        self.__value = value

# 访问私有变量
obj = MyClass(10)
print(obj._MyClass__value)  # 输出：10

# 修改私有变量
obj.set_value(20)
print(obj.get_value())  # 输出：20

在这个示例中，_MyClass__value是私有变量，用于存储类的内部状态。通过在属性名前加两个下划线来表示私有变量。外部可以通过访问_MyClass__value来获取和修改私有变量，但通常不建议这样做，因为这样会破坏封装性。

需要注意的是，虽然私有变量可以防止外部直接访问，但它们仍然是可访问的。在Python中，可以通过在类名后加两个下划线和属性名来访问私有变量，如_MyClass__value。

4.什么是多态

多态（Polymorphism）是指同一个操作在不同的类型上可以具有不同的行为。在面向对象程序设计中，多态是一种重要的特性，它允许我们编写通用代码，以处理不同类型的数据。

在多态中，我们使用抽象类型（接口、抽象类）来定义通用行为，然后让具体类型（类）来实现这个行为。这样，我们就可以编写通用的代码，以处理不同类型的数据。

在Python中，多态主要通过实现接口（抽象类）和继承（继承抽象类）来实现。

例如，我们可以定义一个抽象类Shape，包含一个方法area()，用于计算形状的面积。然后，我们可以创建具体的类Circle和Rectangle，分别实现Shape的area()方法。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

现在，我们可以创建一个通用函数calculate_area()，接收一个Shape类型的参数，然后根据参数的类型调用相应的area()方法，以计算其面积。

def calculate_area(shape):
    return shape.area()

circle = Circle(5)
rectangle = Rectangle(4, 6)

print(calculate_area(circle))  # 输出：78.5
print(calculate_area(rectangle))  # 输出：24

在这个例子中，我们定义了一个抽象类Shape，包含一个抽象方法area()。然后，我们创建了具体的类Circle和Rectangle，分别实现了area()方法。最后，我们编写了一个通用函数calculate_area()，接收一个Shape类型的参数，并根据参数的类型调用相应的area()方法，以计算其面积。这样，我们就可以处理不同类型的数据，实现多态。

5.继承的优点、分类、语法

继承是一种代码重用机制，可以让我们创建新的类，该类继承自现有的类，从而使用现有类的属性和方法。继承的优点主要有以下几个：

  1. 代码重用：通过继承，我们可以创建新的类，该类可以继承自现有的类，从而使用现有的类中的属性和方法。这使得代码更加模块化，便于维护和扩展。

  2. 扩展功能：通过继承，我们可以扩展现有类的功能，创建新的属性和方法，从而满足特定的需求。

  3. 代码可读性：继承可以帮助我们创建更具可读性的代码，因为子类通常会继承父类的名称和文档字符串，这使得子类的文档更加详细和易于理解。

继承的分类主要有两种：

  1. 单继承：一个类继承自一个父类，称为单继承。

  2. 多继承：一个类继承自多个父类，称为多继承。

Python中使用继承的语法如下：

class 子类名(父类名):
    def __init__(self):
        父类名.__init__(self)
        # 子类特有的属性和方法

例如，我们可以定义一个Animal类，包含一个抽象方法move()，然后创建一个Dog类，继承自Animal类，并实现move()方法。

class Animal:
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def __init__(self):
        super().__init__()

    def move(self):
        print("The dog is running")

在这个例子中，Dog类继承自Animal类，并实现了move()方法。在Dog类的__init__()方法中，我们使用super().__init__()来调用父类的__init__()方法，以初始化子类的属性。

第八章：
p159主程序：
# the_   Chinese_Dream.py
people = '我是一个中国人'


def fun_dream():
    '''功能：一个中国梦，无返回值'''
    print("富强，民主，")


if __name__ == '__main__':
    fun_dream()
    people = people + "我正在全力以赴追梦"
    print(people)
    
#if,直接运行本模块，本模块的__name__的值是__main__，
#if，不是直接运行本模块，本模块的__name__这个变量不等于是__main__，
#if __name__== '__main__'为false,则不执行后面的语句

另一个文件调用时：

import tft
print(tft .people)

我是一个中国人

主函数的所有不会输出

所有异常：
a=1
b=0
try:
    a/b
except:
    print("错误：除数不为零")
    
print("++++++")
捕获普通异常：
a=1
b=0
try:
    a/b
except ZeroDivisionError:
    print("错误：除数不为零")

print("++++++")
捕获多个异常：
a=1
b=0
try:
    a/b
except (ZeroDivisionError,TypeError):
    print("错误：除数不为零")

print("++++++")
万能异常：
a=1
b=0
try:
    a/b
except Exception as e:
    print("错误：除数不为零",repr(e))

print("++++++")

错误：除数不为零 ZeroDivisionError('division by zero')

进程已结束，退出代码为 0

else语句:
try:
    print("这一行，如果报错，执行except语句，不报错，则执行else语句")
    1/0
except:
    print("except语句")
else:
    print("else语句")

这一行，如果报错，执行except语句，不报错，则执行else语句 except语句

进程已结束，退出代码为 0

finally:
try:

    a=1
except:
    print("错误：除数不为零")
finally:
    print("清除a")
    del a
    print("a已经清除")
    #finally语句无论是否报错，都会执行,读取文件时，用来关闭文件流

清除a a已经清除

进程已结束，退出代码为 0

raise语句：

try:
    a= input()
    if(not a.isdigit()):
        raise(ValueError("提示：输入的必须是数字"))
except ValueError as e:
    print("抛出异常",repr(e))
# 执行try里面的代码块，如果有错，主动抛出raise()里面的错误类型，抛出错误会被except捕获，然后执行执行except后面的代码块

w 抛出异常 ValueError('提示：输入的必须是数字')

进程已结束，退出代码为 0

杜小杜*
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值