12分钟入门python基础-计算机视觉方向

星创小白

已于 2023-07-14 00:01:56 修改

阅读量760

点赞数 1

文章标签： python 开发语言

于 2023-03-29 17:33:43 首次发布

本文链接：https://blog.csdn.net/weixin_45399776/article/details/129812017

版权

本文详细介绍了Python的基础知识，包括环境搭建、命名规范、函数和变量的使用，数学思维在编程中的应用，以及Python的分支与循环语句。特别强调了Python的数据类型，如整数、浮点数、布尔型、列表、元组、字符串和字典，以及它们的操作方法。此外，还涵盖了字符串函数、文件操作、类与对象的概念，以及异常处理机制。

摘要由CSDN通过智能技术生成

0.环境搭建和界面使用

0.1命名规范

函数和变量为了方便代码阅读最好使用标准的英文，有的高校在大学生进行代码学习的时候就有着用英语进行命名的要求。

对于常量一般设置为大写。比如ALL

对于变量一般遵循小写字母并且通过下划线的方式进行连接。

对于函数名同变量

对于类名使驼峰法则，也就是单词的首字母大写

0.2快捷键使用

快速复制当前行到下一行：ctrl+D

运行：自定义，比如可以为shift+F键

快速搜索：ctrl+F

0.3python中的数学思维

遍历法

一.python语法——如大纲一样有序且简洁

1.1python语言换行自动切换语句

换行就表示切换下一个语句,不需要加分号，但是加上分号也不算错

print("我要开始玩python喽")
print("这是我学习编程的第一天")

1.2多行一语句

1.2.1 使用分号连接多个行，形成一个语句

small=1;medium=2;large=3
size=small+\
     medium+\
     large

1.2.2 三引号可以实现多行注释或者多行输出

'''我们可以用
三个引号来表示注释
可以进行跨行注释
'''
print('''我们可以用
三个引号来表示注释
可以进行跨行注释
''')

1.2.3 小括号，中括号，大括号，尖括号中的内容可以跨行写

k=[3,
   4,
   5]

1.3一行多语句

使用分隔符对多个语句进行分开

hight=1.80;weight=146
print(hight,weight)

1.4注释

#用来表示单行注释。单行注释快捷键，ctrl+/

1.5缩进

如果语句B是语句A的递进关系，也就是说如果B是A语句中的内容，那么语句B会在语句A的基础上增加缩进。

如果语句A与语句B之间是并列关系，那么他们之间的缩进相同。

冒号表示递进的，表示冒号之后的内容是在冒号之前的框架之中。

1.6

        if __name__ == '__main__':
        这样写可以让主要的内容不被import,节省程序运行的效率

二.交互语句——如聊天一般的交互语句

灵活的python输出语句

2.1Python基本输出形式

print语句中整式以数值的形式直接输出，字符串加上引号，单引号，双引号或者三引号都可以。
不同的print语句之间自动换行，如果想实现不换行的效果可以使用end=""方法，

print("我要开始玩python喽")
print("这是我学习编程的第一天")
a=3;b=4;c=5
print((a+b+c)*3)
print(a,end="")
print('的下一个值是',end="")
print(b)

2.2传统C语言表达式

也可以使用传统C语言的语句进行编写，但是格式上稍微有些改动。

%d表示整型变量（10进制），%s表示字符串，%f表示浮点型变量，%c表示字符，%X表示16进制的数大写，%x表示16进制的数，小写。

print("1+2的结果是%d" %a)
print("%d的下一个值是%d" %(a,b))
hello='hello,萨瓦迪卡   '
xxx=18
print("%s我的年龄是%d" %(hello,xxx))

2.3 f表达式

print(f'{hello}我的年龄是{xxx}')

用于省去c语言格式的麻烦直接进行混合输出

2.4转义字符

1.\n换行

2.\t空出一个tab键

2.5.输入交互

用一个变量来存储输入的信息，python输入的信息一般都是以字符串的形式存储起来的

test=input("请输入信息：")
print(f'你数日的信息是:{test}')
print(type(test))

聊天式开发

使用pycharm界面下的python console界面可以开启类似matlab的交互式界面，也就是所谓的实时编程。

三.分支与循环语句

3.1布尔表达式

设置一个区间，用于判断范围

比如40到60的num变量

我们可以写成40<=num<=60

aim=30
if 20<=aim<=40:
    print('我们的目标在范围之内')

可以使用and 或者or来确定数据的交并关系

3.2.1if语句

xingbie=input("请输入你的性别（男/女）")
if xingbie=='女':
    print(f'欢迎来我们学院，因为我们这样的理工学院很缺少{xingbie}生')
print("欢迎结束")

if语句冒号之前表示条件，冒号之后表示条件成立之后所执行的内容，所执行的内容从冒号开始到下一个与if平级的语句结束

需要注意的是，当得到一个输入值之后，得到是一个str类型的变量，当进行bool表达式

比较的时候，需要进行同一种数据类型的变量的比较，所以往往需要用到数据类型转换。

当多个比较运算同时存在的时候可以使用or或者and语句来增加判断

3.2.2.if...else语句

xingbie=input("请输入你的性别（男/女）")
if xingbie=='女':
    print(f'欢迎来我们学院，因为我们学院很缺少{xingbie}生')
else:
    print("请您务必要考虑一下，毕竟我们专业的男女比例不是那么友好")

3.2.3.if...elif...else语句

xingbie=input("请输入你的性别（男/女）")
if xingbie=='女':
    print(f'欢迎来我们学院，因为我们这样的理工学院很缺少{xingbie}生')
elif xingbie=='男':
    print("请您务必要考虑一下，毕竟我们专业的男女比例不是那么友好")
else:
    print("变性人？")

同时可以不添加else语句，只增加if...elif语句

3.2.4if语句的嵌套

if语句使用嵌套的逻辑类似于层级关系

xingbie=input("请输入你的性别（男/女）")
if xingbie=='女':
    haveornot=input("你有男朋友吗？")
    if haveornot=='有':
     print(f'欢迎来我们学院，因为我们学院很缺少{xingbie}生')
    elif haveornot=='无':
     print(f'不要再犹豫了，我们很需要你')
elif xingbie=='男':
    print("请您务必要考虑一下，毕竟我们专业的男女比例不是那么友好")
else:
    print("变性人？")

3.3循环语句

3.3.1while语句

循环语句累加器有从0开始的习惯

k=1
while k<100:
    print("你说的好",end='')
    k=k+1

3.3.2for循环

for循环循环的是数列中的内容

比如使用for循环进行字符串操作

break

break跳出本层循环

continue

continue跳出本次循环

当使用continue的时候，需要在continue之前修改计数器，否则会进入死循环

s='hello'
for i in s:
    if i!='e':
        print(i,end='')

四.数据类型

python无需对变量进行类型的定义

4.1整数型

内存：大小没有限制，仅受限于可用内存的大小

运算：对整数进行+-***的运算结果会是整数，对整数进行/运算将会出现浮点数，使用//运算符可以将整数进行截断。

4.2浮点数型

对x定义一个符数型数，那么x.real表示x的实部，用x.imag表示x的虚部。

4.3布尔型

True和False默认表示1和0

不同数据之间进行强制类型转换

比如

将数据转换为整数类型，int()

4.4列表（list）

列表使用中括号进行表示，列表之间的数据使用逗号进行连接，使用list(x)函数进行强制类型转换。

表数据是可变的，列表数据是可变类型

字符串可以看成一种特殊的列表

4.4.1creat the list

使用中括号[ ]

直接建立列表，使用逗号在不同的数据之间做一个分割，列表之中可以使用不同类型的数据。

也可以使用list()函数对目标进行强制类型转换和建立。

radom=[3,1,45,5, 5,7,5]
print(radom)
radom1=list(radom)
print(radom1)

4.4.2find the data in list

我们使用从零开始的正数来表示从前往后的数字，而使用从-1开始的负数来表示从后往前的数字

radom=[3,1,45,5, 5,7,5]
print(radom[0])
print(radom[1])
print(radom[2])
print(radom[3])
print(radom[4])
print(radom[-1])
print(radom[-2])
print(radom[-3])

我们使用类似于matlab矩阵检索的方法对元组进行检索，：前后分别表示开始和结束的列表值的下标，是前闭后开的结构。如果是：：结构那么表示是前闭后开的取值区间，第三个值代表步长，然后如果省略就代表最前面或者最后面。

ability=['数学', '物理', '编程', '英语', '机械', '电路', '英语']
print(ability[1:3])
print(ability[1:])
print(ability[:3])
print(ability[:])
print(ability[::2])
print(ability[1:3:2])
print(ability[::-1])
print(ability[::-2])

['物理', '编程']
['物理', '编程', '英语', '机械', '电路', '英语']
['数学', '物理', '编程']
['数学', '物理', '编程', '英语', '机械', '电路', '英语']
['数学', '编程', '机械', '英语']
['物理']
['英语', '电路', '机械', '英语', '编程', '物理', '数学']
['英语', '机械', '编程', '数学']

验证特定字符串是否在列表中，使用使用特定字符串，开始字符和结束字符作为第一个到第三个参数

str.index(sub[, start[, end]])

list11=[3,2,'bc','dd',5]
print(f'含有数字五的元素在list11中是第{list11.index(5,0,5)+1}位')

4.4.3增

1.append函数是增加的意思，

2.extend函数也是在末尾增加的意思

list11=[3,2,'bc','dd',5]
list11.append("小明")
print(list11)
#在末尾追加元素

3.insert()在指定位置增加数据

insert(位置下标，数据)，比如下标为2，那么新增的数据将会作为新列表的第3 个，也就是列表中的2的位置

list11=[3,2,'bc','dd',5]
list11.insert(1,'aa')
print(list11)


输出结果是：
[3, 'aa', 2, 'bc', 'dd', 5, '小明']

4.4.4删

4.4.4.1对列表整体进行删除

del函数

list22=[11,22,33,4,55]
del list22
print(list22)

4.4.4.2对指定对象进行删除

pop函数是删除后返回被删除列表的元素的函数

list22=[11,22,33,4,55]
#pop函数是删除后返回被删除列表的元素的函数
list222=list22.pop(2)
print(list22,list222)


   其结果为

[11, 22, 4, 55] 33

4.4.4.3remove函数删除指定内容

list22=[11,22,33,4,55]
#pop函数是删除后返回被删除列表的元素的函数
list222=list22.pop(2)
print(list22,list222)
list22.remove(22)
print(list22)

其结果为：
[11, 22, 4, 55] 33
[11, 4, 55]

4.4.5 改变列表内容

1.reverse函数

反转函数，作用是把数列的顺序翻过来

list_num=[ 1,2,3,4,5,6,7,8,9]
list_num.reverse()
print(list_num)
list_num.reverse()
print(list_num)

其结果为
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

2.sort函数，排序函数，比较常见

3.copy函数，复制内容

4.4.6.对列表实现循环

while i<len(列表名)

for i in 列表名

#为老师随机分配办公室
import random
teachers=['A','B','C','D','E','F','G']
room=[[],[],[]]
for name in teachers:
      room[random.randint(0,2)].append(name)
print(room)

检验效果程序

i=0
for ro in room:
    print(f'办公室{i}的人数是，{len(ro)}')
    for  r in ro:
        print(r)
    i=i+1

最终实现效果程序

[['A', 'E'], ['D', 'G'], ['B', 'C', 'F']]
办公室0的人数是，2
A
E
办公室1的人数是，2
D
G
办公室2的人数是，3
B
C
F

4.5元组(tuple)

元组和列表类似，但是元组是不可修改的。元组和列表之间可以直接转换。元组使用 tuple(x)进行强制类型转换。元组需要在每一个元素的后面加上逗号。

元组使用小括号（）

#元组详解博客

python元组详解http:// https://blog.csdn.net/m0_70885101/article/details/125999020

4.6 字符串(string)

单行字符串用单引号或者双引号

多行可以用三单引号或者三双引号。

4.7.字典(dict)

字典使用大括号{}

字典的存储方式是键值对应，他更像一个具有属性的数据集合。一个键值使用冒号对键值的内容进行对应

字典的数据是以键值对出现的，不支持下标查找

键值对是用逗号隔开的，键值和内容之间是使用冒号建立的。

4.7.1增

dic={'name':'小名','age':21,'gender':'男'}
print(dic['name'])
dic['爱好']='羽毛球'
print(dic)

没有的键值对应的内容可以自动增加，如果有了之后也可以修改，不过修改需要更改下标

4.7.2删

dic={'name':'小名','age':21,'gender':'男'}
del(dic['name'])
print(dic)

删除del(字典名称加下标，下标中是键)

4.7.3查

get函数用于查找字典，类似于list的index,find函数

dic={'name':'小名','age':21,'gender':'男'}
del(dic['name'])
print(dic)

print(dic.get('name'))
print(dic.get('age'))

key函数返回字典中所有的键值。

values函数返回字典中所有的内容

items函数返回字典中所有项目的内容，所有的项目以元组的形式存储起来

4.7.4遍历

对字典中的内容进行遍历可以进行key值的遍历，value的遍历，以及items的遍历

也可以同时对key和values进行遍历，

dic={'name':'小名','age':21,'gender':'男'}
for key,values in dic.items():
    print(f'{key}={values}')

4.7.5表达式

建立字典的时候使用表达式，建立一个赋值，可以使用简便的表达式快速赋值，这是其它语言难以具备的

#创建字典的循环表达式
dicti={i:i**2 for i in range(5)}
print(dicti)

结果是

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python语言的特点是，聪明，只要你能够表达清楚变量是代之的哪个循环部分，就可以把他循环出来。

接下来以合并列表为例

展示一种用列表生成字典的方法

#首先先新建两个列表
list_1=[1,2,3,4,5]
list_2=['小宇','小王','小孙','小张','小杨']
dictii={list_1[i]:list_2[i] for i in range(len(list_1 ))}
print(dictii)

然后使用if语句进行筛选


#首先先新建两个列表
list_1=[1,2,3,4,5]
list_2=['小宇','小王','小孙','小张','小杨']
#使用for循环新建列表
dictii={list_1[i]:list_2[i] for i in range(len(list_1 ))}
print(dictii)
#使用if语句筛选满足条件的字典内容
dictiii={i:j for i,j in dictii.items() if i>2}
print(dictiii)

注意，集合的语法与其类似，只不过集合没有键值

4.8.集合（set）

集合是大括号{}

这里不需要键之类的特殊类型的值，存储方式与list和tuple类似

集合数据具有去重功能，会自动删除重复项

集合是可变类型

4.8.1创建集合

#创建集合的方式
jihe={1,2,3,4,5,6,7,8}
#我们也可以使用set函数的形式创建集合
print(jihe)
xiaojihe=set("snadsda")
print(xiaojihe)

最终结果如下

{1, 2, 3, 4, 5, 6, 7, 8}
{'a', 'd', 'n', 's'}

一、2创建空集合

创建空集合的时候智能使用set函数，因为{}用于创建空字典

4.8.2增加集合

对集合进行增加运算

add是单个进行增加

update是对序列进行增加

#创建集合的方式
jihe={1,2,3,4,5,6,7,8}
#我们也可以使用set函数的形式创建集合
print(jihe)
xiaojihe=set("snadsda")
print(xiaojihe)
jihe.add(9)
print(jihe)
jihe.update([10,11,12,13])
print(jihe)

4.8.3删除集合

remove删除集合，删除指定内容，如果不存在将会报错

discard删除集合，删除指定内容，如果不存在将不会报错

4.9数据类型转换

int(test_number)
float(test_number)
str(test_number)
tuple(test_number)
list(test_number)
chr(test_number)#将变量转变为字符（ASC11）
ord(test_number)#将字符转变为（ASC11）中字符所对应的数字
hex(test_number)#将字符转变为16进制值
eval(test_number)#将字符转变为其原有的符号类型，目前感觉有些鸡肋

五.运算符号——与其它语言类似的符号

5.1算数运算符

** 表示乘方// 表示整除% 表示取余

+号用于连接，不只是数字，还可以连接字符串，列表和元组

*号用于复制，不只是数字，还可以复制字符串，列表和元组

5.2比较运算符

1.比较运算符返回的是一个bool表达式

==等于号

2.使用 in 或者 not in 检测字符串，元组，列表，字典

Python 中 in 的用法总结_python中in的用法_zhangvalue的博客-CSDN博客

5.3赋值运算符

a=b=c=2 表示多变量赋值

num1,float1,string1=2,2.1,'02'
print(f'{num1}   {float1}   {string1}')

5.4逻辑运算符

and 表示和运算

or 表示或运算

not 表示非运算

比较运算符和逻辑运算符放在一起的时候为了避免歧义常常采用给比较运算符加括号的方式使得程序看起来更加地规范

3. and 和or也可以作为数值进行输出，但是有些不好掌握

a=0
b=1
c=3
print(b and c)
print(c and b)
print(b or c)
print(c or b)

最后输出结果如下

也就是说，and运算符得出的结果是后一个值的结果，or运算符得出结果是第一个非0值。

7.字符串函数

7.1下标使用:

查找具体内容的方式与列表一致，可以看作一个特殊的列表，下标的形式是[ ]，下标从0 开始

7.2 查找：

ss="welcome to this place"
print(ss.find('to'))#8

find函数返回单词所在的位置，不包含空格,如果没有找到就返回0，

find函数限制范围的写法find(查找内容，开始字数，结束字数)

ss="welcome to this place"
print(ss.find('la',8,20))

7.3 修改

字符串是不可改变类型，所以修改之后的字符串要用新的变量来赋值

ss="welcome to this place,welcome again"
print(ss.find('la',8,20))

new_ss=ss.replace("welcome","don't welcome")
print(new_ss)
#don't welcome to this place,don't welcome again

7.4split分割

丢失分割字符

new_ss='dont welcome to this place,dont welcome again'
list1=new_ss.split("welcome",2)
list11,list22,list33=list1
print(list11)
print(list22)
print(list33)
####################输出结果######################
dont 
 to this place,dont 
 again

不丢失分割字符

rfind函数进行分割

#######一个给文件改名加上备注的函数##################
str_exap='test.txt'
point=str_exap.rfind('.')
print(str_exap[point:])
print(str_exap[:point])
new_str_exap=str_exap[:point]+'[备份]'+str_exap[point:]
print(new_str_exap)

#######################运行结果#######################
.txt
test
test[备份].txt

7.5join合并

与分割字符串功能相反，作用是连接字符串

###############split函数将代码分成了列表，join函数将列表中的字符串重新串了起来##########

new_ss='dont welcome to this place,dont welcome again'
list1=new_ss.split("welcome",2)
print(list1)
new_joined_list="".join(list1)
print(new_joined_list)

###################result###########################
["don't ", " to this place,don't ", ' again']
don't  to this place,don't  again

7.6检测函数

对字母，数字，数字加字母，空白的检测

aa="123a"
bb=""
cc="asdas"
print(cc.isalpha())#是否全是字母
print(aa.isdigit())#是否全是数字
print(bb.isalnum())#是否全是字母或者数字
print(bb.isspace())#是否有空白

8.函数

8.1函数的概念

函数的作用是为了方便代码复用

与c语言相同的是，都是先声明后使用

建立一个简单的含有返回值的函数的示例

def addself(i):
    i=i+1
    return i
print(addself(2))

8.2函数的说明文档

函数的说明文档常常位于函数的开头，用多行注释表示

8.3函数嵌套

可以使用一个函数的返回值作为另一个函数的形式参数

也可以在另一个函数里面调用另另一个函数

8.4函数的形参和实参

形参就像一个盒子，作用是确定在函数中占据的位置。实参是往盒子里面装上具体内容。

函数可以设置默认值，参考如下：

def student_information(name,age,gender='男'):
    print(f'name={name},age={age},gander={gender}')

student_information('小明',22)

8.5递归，函数调用函数

函数的入口不仅可以加入变量还可以传递函数

递归是把函数本身放在函数体里面

调用是在函数体里面调用其它类型的函数

比如

def add(a,b,f):

return f(a)+f(b)

print(add(1,2,abs))

8.6函数的全局变量和局部变量

如果想再函数中定义一个全局变量，可以使用global函数

8.7函数的返回值

函数的返回值可以是一个数据，也可以是列表，元组，字典的形式

8.8匿名函数

lambda函数，一种简化格式的函数写法

sum_3=lambda x,y,z:x+y+z
print(sum_3(1,2,3))

九.文件

9.1最基本operating

w+	开头重新写入，会清空之前的内容,没有文件的时候会新建文件
r	不清空之前的内容
r+	不清空之前的内容，可以读取也可以写入
a	在末尾写入，不清空之前的内容
a+	在末尾写入，不清空之前的内容，没有文件会新建文件

f=open('new.txt','w')
f.write('ss')
f.close()

结果：清空前面的内容进行写入

f=open('new1.txt','a')
f.write('ss')
f.close()

结果：在原文件的后面进行写入

对文件进行整个读取


f=open('new1.txt','r')
print(f.read())
f.close()

对文件进行拆分读取

f=open('test.txt','r')#读取文件
test_store=f.readlines()#将文件以列表的形式存储
print(test_store[0])#输出文件的第一行
f.close()#关闭文件

9.2文件指针

seek 偏移量（对于起始位置来说）

0：文章开头 1：当前位置 2：文章末尾

9.3 operating system

使用operatingSystem需要导入包，也可以称为导入头文件，就像一个工人拿到一个工具箱一样，只不过相比于现实情况，这个导入是十分高效的。

9.3.1重命名与删除

import os
os.rename('new.txt','newnew.txt')
#对当前路径的文件进行重命名

import os
# os.rename('new.txt','newnew.txt')
os.remove('newnew.txt')

9.3.2对文件夹的一些操作

1、新建和删除文件夹

#新建文件夹，make   dir(显示文件列表)
os.mkdir('new_file')
#删除文件夹，remove dir
os.rmdir('new_file')

2.路径问题

#获取当前目录
os.getcwd('new_file')
#改变目录路径
os.chdir('new_file')
#返回当前路径下的所有文件列表
os.listdir('new_file')

十.类与对象

10.1类的概念

类，比如猫科类动物类，他有很多猫科动物的共同特征，比如老虎，豹子，猫，他们被称为对象，而猫科类动物统称为类。我们使用对象的时候，只需要设置一个变量，让他等于对象就好了。

10.2类的函数，对象用

类创建一个函数的时候，会涉及self

10.3对象创建

对象可以建立，同时对象的属性可以设置

class student():
    def study(self):
        print('能洗衣服')
        #类建立的方法可以称为对象方法，是给对象用的
monitor=student()#创建对象的方法
print(monitor)
monitor.study()
monitor.high=150
monitor.weight=120
print(monitor.high)

class student():
    def study(self):
        print('能洗衣服')
        #类建立的方法可以称为对象方法，是给对象用的
        print(f'这个学生的身高是{self.high}')
        print(f'这个学生的体重是{self.weight}')
monitor=student()#创建对象的方法
monitor.high=150
monitor.weight=120
print(monitor)
monitor.study()

10.4内置函数

也称为特殊方法，为了表示这个函数很特殊，在其前后使用下滑线表示

10.4.1init函数

具有特殊功能的函数_init_,可以作为类的特征的初始化

class books():
    def __init__(self):
        self.high=20
        self.weith=15
    def print_attribute(self):
        print(f'一般书籍的长度是{self.high}')
        print(f'一般书籍的宽度是{self.weith}')

comic=books()
comic.print_attribute()

_init_对象在创建的时候就被调用，不需要手动再去调用

同时我们可以把参数的特性作为函数的输入入口，这样就得到了具有参数属性的对象。

class books():
    def __init__(self,high,weith):
        self.high=high
        self.weith=weith
    def print_attribute(self):
        print(f'一般书籍的长度是{self.high}')
        print(f'一般书籍的宽度是{self.weith}')

comic=books(30,18)
comic.print_attribute()

10.4.2_str_函数（对象说明函数）

str函数用于将来对对象进行打印的时候可以对对象做一些说明

class books():
    def __init__(self,high,weith):
        self.high=high
        self.weith=weith
    def print_attribute(self):
        print(f'一般书籍的长度是{self.high}')
        print(f'一般书籍的宽度是{self.weith}')
    def __str__(self):
        return "这是一个特殊的书籍"
comic=books(30,18)
comic.print_attribute()
print(comic)

10.4.3def del(self):（对象删除函数）

10.5对象举例

10.5.1-烤地瓜（实现生活场景交互）

我们可以使用__init__函数来建立地瓜类的一些基本特性

接着建立一个类所固有的类函数，在类的建立里面把他不同的参数建立一个简单的逻辑关系。接着使用__stl__语句表示出来

class sweetPotato():
    def __init__(self):
        self.cooktime=0
        self.state='生的'
        self.condiment=[]
    def __del__(self):
        print('object has been deleted')
    def cook(self,time):
        self.cooktime+=time
        if 0<=self.cooktime<3:
            self.state='生的'
        elif 3<=self.cooktime<5:
            self.state='半生不熟'
        elif 5<=self.cooktime<8:
            self.state='熟了'
        else:
            self.state='熟透了'
    def __str__(self):
        return f'这个地瓜烤的时间是{self.cooktime},现在已经{self.state}了'
    #改函数用于删除对象

在类中，经常会有自身调用自身的特点，这个时候会使用sel这个参量实现对自身的调用，一般使用类函数都会在函数的入口加上self，但是实际上self函数在外部调用的时候并不需要写上

10.5.2 -搬家具（实现简单数学运算交互）

建立一个在新家装填家具的代码，

建立了两个类

自定义设置家的名称和大小，自定义设置家具的名称和占地面积

使用addFuniture函数为自定义的家添置家具并计算剩余面积

class Funiture():
    def __init__(self,name,area):
        self.name=name
        self.area=area
    def __str__(self):
        return f'家具的名字是{self.name}，家具的占地面积是{self.area}'
class Home():
    def __init__(self,adress,area):
        self.adress=adress
        self.area=area
        self.free_area=area
        self.Funiture_list=[]
    def addFuniture(self,item):
        if self.free_area>item.area:
            self.free_area-=item.area
            self.Funiture_list.append(item.name)
        else:
            print("sorry,the room is full")

    def __str__(self):
        return f'房屋的地址是{self.adress}，家具的占地面积是{self.area},房屋的剩余面积是{self.free_area},房屋的家具有{self.Funiture_list}'
Two_bed=Funiture('红木双人床',16)
yello_chair=Funiture('黄色的椅子',8)
nottree=Home('北京',1200)
print(Two_bed)
print(nottree)
nottree.addFuniture(Two_bed)
print(Two_bed)
print(nottree)
nottree.addFuniture(yello_chair)
print(Two_bed)
print(nottree)

十一.继承

继承就是儿子继承父亲的一些特征。

11.1一个子类继承父类的简单例子

1.首先建立一个父类

class Father():
    def __init__(self):
        self.num=1
    def __str__(self):
        return f'这是建立了一个父类'
Big_Father=Father()
print(Big_Father)

2.接着建立一个子类进行继承

注意，类方法一般都会对自身进行调用，所以每个括号中要添加self

class Son(Father):
    pass
small_son=Son()
print(small_son.num)

super函数进行快捷继承

super(类名称，self)

3.多继承

多继承的使用方法是使用括号添加多个对象

除此之外，我们可能不仅继承一个师傅的衣钵，所以我们常常需要向不同的师傅学习

也就是一个徒弟常常需要继承多个师傅的特点，而一般情况下，会默认使用第一个师傅的各种属性

class Father(object):
    def __init__(self):
        self.num=1
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def __str__(self):
        return f'这是建立了一个父类'
Big_Father=Father()
print(Big_Father)
class Teacher_1(object):
    def __init__(self):
        self.num = 2
        self.learn='语文'
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def __str__(self):
        return f'这是建立了另外一个父类'
class Son(Father,Teacher_1):
    pass
small_son=Son()
small_son.printNow_attribute()

4.子类对父类的精准调用

对不同的父类相同的函数分别进行不重名的设置，方便调用

class Son(Father,Teacher_1):
    def __init__(self):
        self.num = 3
        self.learn = '英语'
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def Father_printNow_attribute(self):
        Father.__init__(self)
        Father.printNow_attribute(self)
    def Teacher_1_printNow_attribute(self):
        Teacher_1.__init__(self)
        Teacher_1.printNow_attribute(self)
    def __str__(self):
        return f'这是建立了另外一个子类'
small_son=Son()
print(small_son)
small_son.Father_printNow_attribute()

11.2 私有属性（独享资源）

建立私有属性，子类无法继承。双下划线加名称

__money是私有属性

建立私有函数，子类无法继承。双下划线加函数名

如下所示，

class Teacher_1(object):
    def __init__(self):
        self.num = 2#num
        self.learn='语文'#subject
        self.__money = 1000#money
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')#自我属性输出

class Son(Teacher_1):
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def Teacher_1_printNow_attribute(self):
        Teacher_1.__init__(self)
        Teacher_1.printNow_attribute(self)
small_son=Son()
print(small_son)
print(small_son.learn)
print(small_son.money)

结果：

有属性建立之后不能直接调用，但是可以通过自己设置调用函数调用，子类只需要调用父类的允许调用函数就可以了。

class Teacher_1(object):
    def __init__(self):
        self.num = 2
        self.learn='语文'
        self.__money = 1000
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def __str__(self):
        return f'这是建立了另外一个父类'
    def get_money(self):
        return self.__money
    def set_money(self):
        self.__money=500
class Son(Teacher_1):
    def printNow_attribute(self):
        print(f'我的代号是{self.num}')
    def Teacher_1_printNow_attribute(self):
        Teacher_1.__init__(self)
        Teacher_1.printNow_attribute(self)
    def __str__(self):
        return f'这是建立了另外一个子类'

small_son=Son()
tall_teacher=Teacher_1()
print(small_son)
print(small_son.learn)
print(small_son.get_money())
small_son.set_money()
print(small_son.get_money())

十二.多态

本文此处的代码来自

05-设置和访问类属性_哔哩哔哩_bilibili

这套视频，代码是学习，用作个人笔记的。侵删。

12.1什么是多态

就是对象继承类的时候的函数表现出差异性，类似遗传物种多样性。

class dog():
    def work(self):
        print("指哪打哪")

class Army_dog(dog):
    def work(self):
        print("追击敌人")

class Drug_dog(dog):
    def work(self):
        print("查找毒品")

#创建了一个父类，两个子类，一个与两个子类相关的旁类
class Person(object):
    def workWithDog(self,dog):
        dog.work()
#接着创建了两个不同类型的对象
Ad=Army_dog()
Dd=Drug_dog()
xiaoMing=Person()
xiaoMing.workWithDog(Ad)
xiaoMing.workWithDog(Dd)

12.2使用类属性节省空间

直接定义类而不是对象可以提高代码简洁性

class dog():
    teeth=10
    def work(self):
        print("指哪打哪")

class Army_dog(dog):
    def work(self):
        print("追击敌人")

class Drug_dog(dog):
    def work(self):
        print("查找毒品")

#创建了一个父类，两个子类，一个与两个子类相关的旁类
class Person(object):
    def workWithDog(self,dog):
        dog.work()
#接着创建了两个不同类型的对象
Ad=Army_dog()
Dd=Drug_dog()
xiaoMing=Person()
xiaoMing.workWithDog(Ad)
xiaoMing.workWithDog(Dd)
print(dog.teeth)
print(Ad.teeth)
print(Dd.teeth)

十三.异常

13.1什么是异常

我们知道写程序的时候有时候会出现一些错误导致报错

比如打开一个不存在文件，

这个时候需要一种语句使得如果出现异常就执行另一种解决方案

程序不报错，使程序能够继续向下执行

13.2异常语法的格式

13.2.1如果错了就怎样语句

try:

可能会出错的语句

except:

解决方案

try:
    f=open('test.txt','r')
except:
    f=open('test.txt','w')

注意，try下方一般只执行一行代码。

有时候异常里面也会出现错误，这个时候为了减少可能会出现的错误，通常会确定指定类型的异常才能触发异常执行

比如

捕获名称异常

try:
    print(num)
except NameError:
    print('有错误')

异常类型有很多,bug多了就懂了

捕获多个异常

try:
    print(1/0)
except (NameError,ZeroDivisionError):
    print('有错误')

对异常类型进行解释


try:
    print(1/0)
except (NameError,ZeroDivisionError) as result:
    print(result)

捕获所有异常

try:
    print(1/0)
except Exception as result:
    print(result)

注：Exception是所有异常的父类

如果错了就怎样，如果没错又怎样语句

try:
    print(1/1)
except Exception as result:
    print(result)
else:
    print('当没有异常的时候执行的代码')

如果错了就怎样，如果没错又怎样，不管怎么样，最后都怎么样

try:
    print(1/1)
except Exception as result:
    print(result)
else:
    print('当没有异常的时候执行的代码')
finally:
    print('异常处理结束了')

13.3了解异常传递

import time
try:
    f=open('test.txt')#通过了第一层异常之后
    try:
        while True:
            contint=f.readline()
            if len(contint)==0:
                break
                #每隔两秒读取一次数据，并且输出，直到数据读取完成为止
            time.sleep(2)
            print(contint)
    except:
        print('意外终止了读取数据')
finally:
    f.close()
    print('关闭文件')

13.4自定义异常类

#自定义异常类
class  ShortInputError(Exception):
    def __init__(self,length,min_len):
        self.length=length
        self.min_len=min_len
        #创建了一个异常类，这个类有什么特点
    def __str__(self):
        return f'你输入的长度是{self.length},不能少于{self.min_len}'
        #创建了一个异常类提示
if __name__ == '__main__':
    try:
        con=input('请输入密码')
        if len(con)<3:
            raise ShortInputError(len(con),3)
#抛出异常类
    except Exception as result:
        print(result)
    else:
        print('密码已经输入完成')

十四.模块和包

模块就是py文件

包就是文件夹

14.1调用包

################直接调用###################

def diaoyong1():
    import math
    print(math.sqrt(9))

##############具体调用####################
def diaoyong2():
    from math import sqrt
    print(math.sqrt(9))

##############从模块导入全部#######
#节省空间的写法
from math import *
print(sqrt(9))
#这种写法不需要再进行
# diaoyong2()

############对模块进行命名################
import math as ma
from time import sleep as sl

print('两秒钟之后会出现结果')
sl(2)
print('人间正道是沧桑')

14.2私域函数

当一个py文件增加了一个

main函数之后，

main函数之下的内容只会在本py文件中使用而不会被其它文件调用

就像一个上了锁的箱子，不能被其它py文件自由使用

14.3搜索顺序

首先是当前目录

然后是python解释器中所有目录

pyhon的默认路径

注意当前模块不要和默认的模块名重名

14.4限制调用

在一个py文件里面

如果使用__all__=[该文件特有参数]

另一个调用这个py文件的文件使用了from Py文件 import*语句

则另一个文件只能调用__all__所规定的参数，

但是这种方式是一种虚约束

一旦使用了其它调用方法就会无视这种限制

被调用的文件

__all__=['hello']
def hello():
    print('hello,Miss Wang')
def seeyou():
    print('sorry I dont like you ')
if __name__ == '__main__':

    hello()

调用的文件

from package import *
seeyou()

导入包

import 包名.文件名

在新建包之后自动生成的__init__py文件中建立__all__=[]列表，在列表中加入允许导入的

模块列表