python超详细的常用笔记（2）

第6章：函数

1.1函数的基础

print()  打印输出
input()  输入
len()    求容器长度的
...
函数可以实现一个具体的功能

（1）函数的定义和调用

#(1)函数的定义与调用
#[1]函数的定义:使用关键字def
#def函数名():
#函数名：遵守命名规则
#参数列表：接受函数中的数据，可以以空
#冒号：表示函数体的开始
# def weather(time,tem):#形参
#     print("日期：{0}".format(time))
#     print("温度：{0}".format(tem))
# #[2]函数的调用
# weather("2022/3/24","23")#传入实参

（2）函数的参数传递

#[1]位置参数(最常用)
# def weather(time,tem):
#     print("日期：{0}".format(time))
#     print("温度：{0}".format(tem))
# weather("2022/3/24","23")
# weather("23","2022/3/24")
#[2]关键字参数
# def weather(time,tem):
#     print("日期：{0}".format(time))
#     print("温度：{0}".format(tem))
# weather(time="2022/3/24",tem="23")
#[3]默认参数
#调用函数时，传入实参,默认参数会被覆盖
# def weather(time,tem=23):
#     print("日期：{0}".format(time))
#     print("温度：{0}".format(tem))
# weather(time="2022/3/24")
#
# def weather(time,tem=23):
#     print("日期：{0}".format(time))
#     print("温度：{0}".format(tem))
# weather(time="2022/3/24",tem=33)
#[4]不定长参数
# *args 传入不定数量的元组形参
# def weather(*args):
#     num=1	
#     for item in args:
#         if num==1:
#             print("日期：{0}".format(item))
#             num+=1
#         else:
#             print("温度：{0}".format(item))
# weather("2022/3/24","23")
# **kwargs 接受不定数量的关键字参数 (字典/json)
def weather(**kwargs):
num = 1
print(kwargs)
for item in kwargs.values():
    if num==1:
        print("日期：{0}".format(item))
        num+=1
    else:
        print("温度：{0}".format(item))
weather(time="2022/3/24",tem="23")

（3）变量的作用域

# 【1】局部变量
# 局部变量的作用域（作用范围）： 当前函数的内部
# 局部变量的生存周期：在函数调用的时候被创建，函数调用结束之后，被销毁（删除）
# 局部变量只能在当前函数的内部使用，不能在函数的外部使用。
# def weather(tem):
#     time="2022/3/24" #局部变量
#     print("日期：{0}".format(time))#函数内
#     print("温度：{0}".format(tem))
# weather(tem="23")
# print("日期：{0}".format(time))#函数外

#【2】
# 全局变量： 就是在函数外部定义的变量。
# 在函数内部可以访问全局变量的值，如果想要修改全局变量的值，需要使用 global 关键字声明
#注意：global == java中的this
# time=""#定义全局变量
# def weather(tem):
#     global time#声明修改全局变量
#     time="2022/3/24" #修改全局变量
#     print("在函数内：")
#     print("日期：{0}".format(time))#函数内
#     print("温度：{0}".format(tem))
# weather(tem="23")
# print("在函数外：")
# print("日期：{0}".format(time))#函数外

（4）返回类型

# 
#return的作用：
#1返回函数内部的值，供外部调用
#2程序代码遇到一个 return 之后，后续的代码不再执行
#3可以返回一个或多个值

#返回一个
# def weather(tem):
#     time="2022/3/24" #局部变量
#     print("在函数内：")
#     print("温度：{0}".format(tem))
#     print("在函数外：")
#     return time
#     print("大二的篮球体育老师是**")
# print("日期：{0}".format(weather(tem="23")))#函数外
#返回多个
#函数调用，得用元组的形式来接收
def weather():
  time="2022/3/24" #局部变量
  tem = "23"
  return time,tem#默认返回为元组
  print("大二的篮球体育老师是**")
wt=weather()
print("日期：{0},温度：{1}".format(wt[0],wt[1]))#函数外

（5）递归函数

#利用递归---求阶层
# def factorial(num):
#     if num==1:
#         return 1
#     else:
#         return num*factorial(num-1)
# print("求3--的阶层:",factorial(3))

（6）组包和拆包

#【1】组包
# 将多个数据值,组成元组,给到一个变量.
# a = 1,2,3
# print(a)#(1，2，3)
# def func():
#     return 1,2#组包
# print("fun():",func())
#【2】拆包
# 拆包:将容器的数据分别给到多个变量，需要注意:数据的个数和变量的个数要保持一致
# a = 1,2,3#定义组包a
# b, c, d = a#拆包
# print(b, c, d)
# def func():
#     return 1,2#组包
# e, f = func()#拆包
# print(e,f)
#【3】在列表的组包和拆包
my_list = [10,20]
a, b = my_list
print(a,b)
my_dict = { ' name' : 'isaac', 'age': 18}
a, b = my_dict# key值
print(a,b)

运行截图：

{1}组包

{2}拆包

 {3}在列表的组包和拆包

1.2：地址运用：

（1）变量地址的引用

引用地址

#（8）引用
#【1】变量地址的引用
#总结：{1}python中数据值的传递的是引用，通过赋值运算符----改变变量的引用地址
#     {2}使用id()查看变量的引用地址，
#     {3}变量的地址与输出入的内容有关，----内容相同>>变量的引用地址就相同
a = 10
b = a
print(a,b)#使用print函数打印变量a和b引用中存储的值
print("地址a：",id(a),"地址b：", id(b))#使出a和b的引用地址
#{1}给a赋予一个相同的值
print("a改变值------------------------------")
a = 10
print(a, b)
print("a = 10>>>地址a：",id(a),"地址b：", id(b))
a = 20
print(a, b)
print("a = 20>>>地址a：",id(a),"地址b：", id(b))
#{2}在函数里改变全局变量的值
def func5(a) :
  #+=对于列表来说,类似列表的extend方法，不会改变变量的引用地址
  global num#声明修改全局变量
  num+=a
  print("func5(a):函数内:>>>",num,id(num))
num=10#不可变类型
print("func5(a):修改前:>>>",num,id(num))#输出调用函数前--num的值
func5(num)
print("func5(a):修改后:>>>",num,id(num))#输出调用函数后--num的值

运行截图：

（2）列表的引用地址

引用地址

#【2】列表的引用地址
#总结：{1}列表中，只有开辟一个新的列表>>>>引用地址才会改变
#     {2}A列表的地址---赋予给--B列表，那么A列表的增删改值，B列表的内容也会变化（增删改值A赋予B的地址不变）
# my_list = [1,2,3]#将列表的引用地址保存到变量my_list
# my_list1 = my_list#将my_list变量中存储的引用地址给到my_List1
#
# #{1}my_list增删改>>>看my_list1的地址变化
# print("my_list:>>",my_list, id(my_list) )
# print("my_list1:>>",my_list1, id(my_list1))
# print("my_list.append(4)-------------------")
# my_list.append(4)#向列表中添
# print("my_list:>>",my_list, id(my_list) )
# print("my_list1:>>",my_list1, id(my_list1))
# print("my_list[2]= 5:------------------------")
# my_list[2]= 5
# print("my_list:>>",my_list, id(my_list) )
# print("my_list1:>>",my_list1, id(my_list1))
# #{2}my_list1开辟一个新的列表>>>>my_list1与my_list的地址变化
# print("my_list1 =[1,2,3]:--------------")
# my_list1 =[1,2,3]
# print("my_list1:>>",my_list1, id(my_list1))
# print("my_list1 =[1,2,3,4]:--------------")
# my_list1 =[1,2,3,4]
# print("my_list1:>>",my_list1, id(my_list1))

地址理解：

运行截图：

 

 （3）引用做函数参数注意点

#（9）引用做函数参数注意点
#总结：{1}数传参传递的也是引用
# my_list = [1,2,3]#全局变量
# def func1(a) :
#     a.append(4)
# def func2():
#     #为啥不加gLobal，因为没有修改my_list 中存的引用值
#     my_list.append(5)
# def func3():
#     global my_list
#     my_list = [1,2,3]#修改全局变量的值
# def func4(a) :
#     #+=对于列表来说,类似列表的extend方法，不会改变变量的引用地址
#     a += a# a = a + a，修改了a变量a的引用
#     print("func4(a):函数内:>>>",a,id(a))
# def func5(a) :
#     #+=对于列表来说,类似列表的extend方法，不会改变变量的引用地址
#     global num#声明修改全局变量
#     num+=a
#     print("func5(a):函数内:>>>",num,id(num))
#
# func1(my_list)#[1，2，3，4]
# func2()#[1，2，3，4，5]
# func3()#[1，2，3]
# # print(my_list)
# #{1}测试变量在函数里的>>>>引用地址变化
# print("b = 10#不可变类型--------------")
# b = 10#不可变类型
# func4(b)#输出函数内-----b的值
# print("func4(a):函数外:>>>",b,id(b))#输出调用函数后--b的值
# print("num=10调用内部修改全局变量的函数--------------")
# num=10#不可变类型
# print("func5(a):修改前:>>>",num,id(num))#输出调用函数前--num的值
# func5(num)
# print("func5(a):修改后:>>>",num,id(num))#输出调用函数后--num的值
#
# #{2}测试列表在函数里的>>>>引用地址变化
# print("func4(my_list)----------------")
# func4(my_list)
# print("func4(a):函数外:>>>",my_list,id(my_list))#[1，2，3， 1，2，3]

运行截图：

 

（4）is和==区别

【1】Python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

【2】区别

==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等

is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同（其中：id就是内存地址）

【3】实例

总结：

1基本数据类型（int，long），String的==和is都是True

原因：他们是临时变量存储在栈中

2

{1}基本数据类型
>>> a = 1 #a和b为数值类型
>>> b = 1
>>>a==b
True
>>> a is b
True
>>> id(a)
14318944
>>> id(b)
14318944

>>> a = 'cheesezh' #a和b为字符串类型
>>> b = 'cheesezh'
>>>a==b
True
>>> a is b
True
>>> id(a)
42111872
>>> id(b)
42111872

{2}对象类型
以下的a==b都为True

>>> a = (1,2,3) #a和b为元组类型
>>> b = (1,2,3)
>>> a is b
False
>>> id(a)
15001280
>>> id(b)
14790408

>>> a = [1,2,3] #a和b为list类型
>>> b = [1,2,3]
>>> a is b
False
>>> id(a)
42091624
>>> id(b)
42082016

>>> a = {'cheese':1,'zh':2} #a和b为dict类型
>>> b = {'cheese':1,'zh':2}
>>> a is b
False
>>> id(a)
42101616
>>> id(b)
42098736

>>> a = set([1,2,3])#a和b为set类型
>>> b = set([1,2,3])
>>> a is b
False
>>> id(a)
14819976
>>> id(b)
14822256

1.3：内置函数

（1）内置函数的方法

（2）实例

#（10）内置函数
#【1】abs（）绝对值
num=-5
print("原本：",num)
print("abs（）:",abs(num))
#[2]ord（）把字符---返回对应的Unicode值
chr1='a'
chr2='A'
print("ord()：",ord(chr1))
print("ord()：",ord(chr2))
#[3]chr() 把Unicode值-----对应的Unicode字符
int1=65
int2=97
print("chr()：",chr(int1))
print("chr()：",chr(int2))

第7章：类与面向对象

1.1类的定义和对象的创建

（1）类和对象的概念

【1】概念介绍[了解]

==面向对象和面向过程,是两种编程思想.== 编程思想是指对待同一个问题,解决问题的套路方式.

• 面向过程: 注重的过程,实现的细节.亲力亲为.
  • 函数
• 面向对象: 关注的是结果, 偷懒.
  • 封装, 继承 和多态(三大技术)

【2】封装, 继承 和多态

{1}封装：封装私变量，暴露set和get方法提供调用

{2}继承：子类—继承—父类，在不创建方法时，就可以通过调用父类的方法，实现方法的调用

{3}多态：一种行为，在父类和及其的子类又不同的变现形式

【3】类和对象[理解]

类和对象,是面向对象中非常重要的两个概念

• 类
  • 类是泛指的,指代多个, 是由对的抽象来的
  • 在代码中, 是通过关键字class定义的
• 对象
  • 对象是特指的,指代一个,是具体存在的
  • 在代码中, 对象是由类创建的

【4】类的组成

• 类名
• 属性: 特性, 变量
  • 一个类的属性有很多,值关注需要使用的,没有用到的不用管
• 方法: 行为, 函数

【5】类的抽象

• 名词提炼法
• 所见即所得

（2）类的定义和对象的创建

【1】类的定义

注意：类名要大写

# 【1】定义car类
#注意：类名要大写
# class Car:
#     wheel=4#轮胎数
#     def drive(self):
#         print('开车方式')
#     def stop(self):
#         print('停车方式')
#
# #【2】对象创建
# my_car=Car()
# print('轮胎数:',my_car.wheel)
# my_car.drive()

【2】创建对象

在代码中,对象是由类创建的.

# 【1】定义car类
#注意：类名要大写
# class Car:
#     wheel=4#轮胎数
#     def drive(self):
#         print('开车方式')
#     def stop(self):
#         print('停车方式')
#
# #【2】对象创建
# my_car=Car()
# print('轮胎数:',my_car.wheel)
# my_car.drive()

（3） 类外部添加和获取对象属性

（4）类内部操作属性 

 （5）类中的访问限制

#(2)访问限制
#[1]私有符号
#java中私有符号：private
#python中私有符号：__
#【2】类里：共有方法--间接获取--私有属性
#class类中的方法def 第一个参数永远是self代表实例化对象,
#在类中通过self---调用自己类的私有属性
#
# class Car:
#     wheel=4#轮胎数
#     __car_master='郑先生'
#     def drive(self):
#         print('开车方式')
#     def stop(self):
#         print('停车方式')
#     def get_car_master(self):
#         print("车主为：{0}".format(self.__car_master))
#     def __goto(self):
#         print('去福州')
#
# my_car=Car()
# print('轮胎数:',my_car.wheel)#共有
# # print('车主：',my_car.__car_master)#私有
# # my_car.__goto             #私有
# my_car.get_car_master()     #通过self返回私有

#【3】类中：1私有方法-获取-私有属性，2共有方法--调用--私有方法
#self--调用--私有属性
#self--调用--私有方法

# class Car:
#     wheel=4#轮胎数
#     __car_master='郑先生'
#     def drive(self):
#         print('开车方式')
#     def stop(self):
#         print('停车方式')
#     def __init_car_master(self):#初始化车主
#         print("初始绑定车主为：{0}".format(self.__car_master))
#     def get_car_master(self):#获取现任该车的车主
#         print('现任该车主为：{0}'.format(self.__car_master))
#         self.__init_car_master()
# my_car=Car()
# my_car.get_car_master()     #通过self返回私有

1.2：构造函数和析构函数

（1）构造函数

【1】self的作用：

 1可以访问到类的所有类型的变量（共有，私有等等）

 2使局部变量--变--全局变量，在赋值时改变变量的值（地址）

3等价：java中的this==python无类中使用global==class中的self

【2】python类中构造函数的方法：__init__(self)

{1}无参构造

#{1}无参构造
#self作用：划分全局和局部
# class Car():
#     #全局变量\成员变量
#     master=''#车主
#     money=''#花费的钱
#     def __init__(self):  # 无参构造方法（不写类中也会默认存在）
#         print()
#     def set_car(self,master,money):
#         self.master=master  #给成员变量赋值，并且作用域为全局
#         self.money=money    #给成员变量赋值，并且作用域为全局
#     def get_car(self):
#         print('车主：{0}'.format(self.master))  #返回master
#         print('buy_money:{0}'.format(self.money))#返回master
#对象的创建
# my_car = Car()#无参构造
# my_car.set_car('郑先生', '12000元')#利用方法给变量赋值
# my_car.get_car()

运行截图：

{2}有参构造

#{2}有参构造
#<1>带全局变量的,有使用self来赋值
#self作用：划分全局和局部
# class Car():
#     # 全局变量\成员变量
#     master=''#车主
#     money=''#花费的钱
#     def __init__(self,master,money):#有参构造方法
#         self.master=master#给成员变量赋值，并且作用域为全局
#         self.money=money# #给成员变量赋值，并且作用域为全局
#     def init_car(self):
#         print('车主：{0}'.format(self.master))#返回master
#         print('buy_money:{0}'.format(self.money))#返回master
#
# my_car=Car('郑先生','12000元')#实例有参构造
# my_car.init_car()

运行截图

#<2>带全局变量的，无使用self来赋值
# class Car():
#     # 全局变量\成员变量
#     master=''#车主
#     money=''#花费的钱
#     def __init__(self,master,money):#有参构造方法
#         print('车主：{0}'.format(master),'buy_money:{0}'.format(money))  # 返回master
#         master=master#给成员变量赋值，并且作用域为全局
#         money=money# #给成员变量赋值，并且作用域为全局
#     def init_car(self):
#         print('车主：{0}'.format(self.master))#返回master
#         print('buy_money:{0}'.format(self.money))#返回master
#
# my_car=Car('郑先生','12000元')#实例有参构造
# my_car.init_car()

 运行截图：

#<3>不带成员变量的
#self作用：划分全局和局部，可以省略成员变量的定义
# class Car():
#
#     def __init__(self,master,money):#有参构造方法
#         self.master=master#创建属性master ,并用外面传入的master进行赋值
#         self.money=money# #创建属性money ,并用外面传入的money进行赋值
#     def init_car(self):
#         print('车主：{0}'.format(self.master))#内部方法调用内部属性
#         print('buy_money:{0}'.format(self.money))#内部方法调用内部属性
#
# my_car=Car('郑先生','12000元')#实例有参构造
# my_car.init_car()

运行截图：

【3】__str__()`

{1}调用时机:
1. `print(对象)`, 会自动调用 `__str__` 方法, 打印输出的结果是 `__str__` 方法的返回值
2. `str(对象)` 类型转换,将自定义对象转换为字符串的时候, 会自动调用
应用:
1. 打印对象的时候,输出一些属性信息
2. 需要将对象转换为字符串类型的时候
注意点:
`方法必须返回一个字符串`,只有 self 一个参数

 {2}实例

#self作用：划分全局和局部
class Car():
    # 全局变量\成员变量
    master=''#车主
    money=''#花费的钱
    def __init__(self,master,money):#有参构造方法
        self.master=master#给成员变量赋值，并且作用域为全局
        self.money=money# #给成员变量赋值，并且作用域为全局
    def __str__(self):
        print("我__str()__被调用了")
        return  '车主：{0},buy_money:{1}'.format(self.master,self.money)
        print('车主：{0}'.format(self.master))  # 返回master
        print('buy_money:{0}'.format(self.money))  # 返回master

my_car=Car('郑先生','12000元')#实例有参构造
print(my_car)#会自动调用 `__str__` 方法,
my_car_str=str(my_car)#`str(对象)` 类型转换,将自定义对象转换为字符串的时候, 会自动调用

 运行截图：

（2）析构函数

【1】del（)

析构函数
调用时机:
	对象在内存中被销毁删除的时候(引用计数为 0)会自动调用 __del__ 方法
	1. 程序代码运行结束,在程序运行过程中,创建的所有对象和变量都会被删除销毁
	2. 使用 `del 变量` , 将这个对象的引用计数变为 0.会自动调用 __del__ 方法
应用场景:
	对象被删除销毁的时候,要书写的代码可以写在 `__del__`中.一般很少使用

引用计数: 是 python 内存管理的一种机制, 是指一块内存,有多少个变量在引用,
1. 当一个变量,引用一块内存的时候,引用计数加 1
2. 当删除一个变量,或者这个变量不再引用这块内存.引用计数减 1
3. 当内存的引用计数变为 0 的时候,这块内存被删除,内存中的数据被销毁

my_list = [1, 2]  # 1
my_list1 = my_list # 2
del my_list  # 1
del my_list1 # 0

 【2】实例：

#【2】析构函数
#{1}sys作用
# 1中getrefcount()作用：用于统计对象引用的数量
# 2getrefcount()会统计临时对象的引用
import sys
class Destruction:
    def __init__(self):#被实例对象
        print('对象被创建')
    def __del__(self):#被临时对象调用
        print('对象被销毁')
#创建对象
des=Destruction()
print('引用对象的个数：',sys.getrefcount(des))

运行截图：

1.3：类方法和静态方法

（1）类方法

#（1）类方法
#类方法上+@classmethod
#类方法的第一个参数为cls，不是self
#类方法--才能修改--类属性（实例对象无法修改类属性）
#实例对象--可以--类方法，类名--不能--实例方法
# class Dom01:
#     count=0#类属性
#     def insert_1(self):
#         self.count=1
#     @classmethod
#     def insert_2(cls):
#         cls.count=2
# #；类的实例修改--类属性（不变）
# dom01=Dom01()
# dom01.insert_1()
# print("实例对象--修改类属性：",Dom01.count)
# print("实例对象--输出实例属性：",dom01.count)
# print("="*10)
# dom01=Dom01()
# dom01.insert_2()
# print("类对象---修改类属性：",Dom01.count)

运行截图：

（2）#注意：类属性和实例属性的区别
	【1】Dom01中的count是类属性
#       def insert_1(self):是实例方法
#          self.count=1
#     【2】 @classmethod  类方法
#       def insert_2(cls):
#          cls.count=2
#     【3】实例方法修改--类属性(创建一个与类属性同名的实例属性),
#         实例方法--调用实例属性，类名不能--调到--实例属性
#      【4】类方法修改--类属性(只有类名调用-类属性，实例掉不到)
#      【5】总结：实例对象---才能调用实例属性，类名---才能调用---类属性

（2）静态方法

#（2）静态方法
#静态方法+@staticmethod
#静态方法：里面不写与类属性相关的内容
# class Dom02:
#     count=0#类属性
#     @staticmethod
#     def insert_3():
#         print("静态方法的值：",Dom02.count)
# dom02=Dom02
# dom02.insert_3()#实例对象--调用静态方法
# Dom02.insert_3()#类名---调用静态方法

运行截图：

（3）类方法和静态方法：总结

# 【1】实例方法（self），类方法(cls)，静态()

# 【2】1类方法和实例方法中有参数，---可以调用--类中的-成员变量（实例/类）。

#     2静态方法不能调用

# 【3】静态方法：用于做与类无关的操作

1.4:继承

（1）继承

#【1】单继承
#子类---调用--父类所有的共有的方法和属性
#      调用--自己定义的共有的方法和属性
#父类
# class Felines:#猫科动物
#     felines_name="猫科动物"
#     def speciality(self):#专业
#         print("猫科动物的特长是爬树")
# #子类
# class Cat(Felines):
#     name="猫"
#     def my_name(self):
#         print("我是：{0}".format(self.felines_name))#子类调用父类的属性
#         print("我的名字是：{0}".format(self.name))
# cat=Cat()
# cat.my_name()#子类调用自己的方法
# cat.speciality()#子类调用父类的方法

运行截图：

（2）多继承

#【2】多继承
#父类
# class English:
#     def eng_know(self):
#         print("具备英语知识")
# class Math:
#     def math_know(self):
#         print("具备数学知识")
# #子类
# class Student(English,Math):
#     def study(self):
#         print("学生任务是学习")
#
# stu=Student()
# stu.study()#调用自己的方法
# stu.eng_know()#调用父类E的方法
# stu.math_know()#调用父类M的方法

运行截图：

 （3）重写

#【3】重写
#子类--重新定义和父类方法名相同的方法

#父类
# class Felines:#猫科动物
#     felines_name="猫科动物"
#     def speciality(self):#专业
#         print("猫科动物的特长是爬树")
# #子类
# class Cat(Felines):
#     name="猫"
#     def my_name(self):
#         print("我是：{0}".format(self.felines_name))#子类调用父类的属性
#         print("我的名字是：{0}".format(self.name))
#     def speciality(self):  # 重写
#         print("{0}会抓老鼠".format(self.name))
#         print("{0}会爬树".format(self.name))
# cat=Cat()
# cat.my_name()#子类调用自己的方法
# cat.speciality()#子类调用重写父类的方法

运行截图：

（4）super（）

#【4】super（）
#在方法里调用--父类的方法

#父类
# class Felines:#猫科动物
#     felines_name="猫科动物"
#     def speciality(self):#专业
#         print("猫科动物的特长是爬树")
# #子类
# class Cat(Felines):
#     name="猫"
#     def speciality(self):  # 重写
#         print("{0}会抓老鼠".format(self.name))
#         print("{0}会爬树".format(self.name))
#         super().speciality()#在方法里调用父类的方法
#
# cat=Cat()
# cat.speciality()#子类调用重写父类的方法

运行截图：

 1.5：多态

#【5】多态
#1在python中，在不考虑对象类型的情况下使用对象
#2关注是对象的行为，而不是对象的类型
#3总结为：一种行为，在不同类下，有不同的表现形式

#父类
class Animal:
    def move(self):
        print("飞/游/跑......")
#子类
class Rabbit(Animal):
    def move(self):
        print("兔子奔奔跳跳")
class Snail(Animal):
    def move(self):
        print("蜗牛缓慢爬行")
#封装方法
def test(obj):#obj作为动态对象，可以动态的调用move方法
    obj.move()
rabbit=Rabbit()
test(rabbit)#接受Rabbit类的对象
snail=Snail()
test(snail)#接受Rabbit类的对象

运行截图：

第8章：模块

1.1基础概论：

(1)模块的概论

#[1]每个.py的文件都是---一个模块

#[2]模块分为：1内置模块，2第三放模块，3自定义模块

(2)模块的导入

【1】模块导入分为2种，import  ,  from ... import ...

【2】使用代码

#[1]import
# import module_demo#导入自定义类
# #{1}调用模块的方法
# module_demo.module_show()#调用模块的方法
# #{2}调用模块中类--的属性和方法
# module=module_demo.Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法

#[2]form---import
# from module_demo import Module_demo#从自定义模块中，导入Module_demo类
# module=Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法

#[3]对导入的模块--起别名
# import module_demo as mod_d
# #{1}调用模块的方法
# mod_d.module_show()#调用模块的方法
# #{2}调用模块中类--的属性和方法
# module=mod_d.Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法

(3)常见标准模块

【1】执行代码

{1}sys模块:与python解析器交互，操作python的运行环境

#[1]sys模块:与python解析器交互，操作python的运行环境
# import sys

# #{1}sys.argv：获取运行程序所在的路径
# print("{1}sys.argv:",sys.argv)#输出当前文件的路劲
# #{2}sys.version:获取python的版本
# print("{2}sys.version:",sys.version)
# #{3}sys.path:获取模块搜索路径，该变量的初值为环境变量PYTHONPATH
# print("{3}sys.path:",sys.path)
# #{4}sys.platform:获取操作平台的名称
# print("{4}sys.platform",sys.platform)
# #{5}sys.exit():退出程序
# sys.exit("{5}sys.exit():程序退出")
# print("sys。。。。。。。")

{2}os 模块：访问操作系统服务的功能

#[2]os 模块：访问操作系统服务的功能
# import os
# import sys
# #{1}os.getcwd():获取python的当前,工作路径
# print("{1}os.getcwd()：")
# path="C:\\Users\\DELL\\PycharmProjects\\dom02"
# #修改前
# chang_front=os.getcwd()
# print("修改前路劲:",chang_front)#获取当前的工作路劲
# #修改后
# {2}os.chdir(path):修改当前脚本的工作路径
# os.chdir(path)
# chang_back=os.getcwd()
# print("修改后路劲：{0}".format(chang_back))
#
# #{3}os._exit():终止python程序
# #写os._exit()与sys.exit的区别
# print("{2}os._exit()")
# print("执行模块前：sys.exit")
# try:
#     sys.exit(0)
# except:
#     print("程序结束")
# print("执行模块前：os._exit()")
#
# try:
#     os._exit(0)
# except:
#     print("程序结束")
#
# print("执行模块前：")

{3}random随机数

#[3]random随机数
# import random
# #{1}random.random():返回（0-1）之间的随机实数
# print("{1}random.random():",random.random())
# #{2}random.randint(1,10):返回[1,10]之间的随机数
# print("{2}random.randint(1,10):",random.randint(1,10))
# #{3}random.choice(seq):从序列seq中随机返回一个元素
# list=["lisi","wanwu","xiaoming"]
# print("{3}random.choice(seq):",random.choice(list))#随机输出lst中的其中一个元素
# #{4}random.uniform(x,y):返回[x,y]之间的随机浮点数
# print("{4}random.uniform(x,y):",random.uniform(1,10))

 {4}time模块

 《1》方法

#[4]time模块

# import time
# #{1}time.time()：获取当前时间的时间戳
# #{2}time.sleep(2)：使程序进入休眠(time),设置的时间，来休息
# print("{1}time.time():")
# print("{2}time.sleep(2)：")
# print(time.time())
# befor=time.time()
# time.sleep(2)#休眠2秒
# # 计算1000的10000次方
# result=pow(1000,1000)
# after=time.time()
# interval=after-befor
# print("计算1000的10000次方--运行时间为：{0}秒".format(interval))
#
# #{3}time.strptime(String,[,format])：将一个时间格式(2022-5-4 9:09:54)---字符串转为--时间元组
# #{4}time.mktime(tuple):将时间元组-转换-秒数
# print("{3}time.strptime(String,[,format])：")
# print("{4}time.mktime(tuple):")
# str_dt="2022-5-4 9:09:54"
# #转换为时间元组
# time_struct=time.strptime(str_dt,"%Y-%m-%d %H:%M:%S")
# print("转换为时间元组:{0}".format(time_struct))
# #转换成时间错
# timestamp=time.mktime(time_struct)
# print("转换成时间错{0}".format(timestamp))
#
# #{5}time.localtime：以struct_time类型来输出本地时间
# print("{5}time.localtime：")
# time_loc=time.localtime()
# print("本地时间为：{0}".format(time_loc))

# #{6}time.strftime()：将字符串--时间
# print("{6}time.strftime()：")
# str_dt="2022-5-4 9:09:54"
# time_str=time.strftime(str_dt)
# print(time_str)

#{7}将本地时间—格式化
time_loc=time.localtime()
print(time.strftime("%Y-%m-%d-%H_%M_%S", time_loc))

《2》注意：

<1> time.strptime(String,[,format])：strptime里的参数—要与. String串时间格式-一一对应

str_dt="2020年1月15日10点30分23秒"
time_struct=time.strptime(str_dt,"%Y年%m月%d日%H点%M分%S秒")

《3》运行截图：

 #{1}time.time()：获取当前时间的时间戳
#{2}time.sleep(2)：使程序进入休眠(time),设置的时间，来休息

 #{3}time.strptime(String,[,format])：将一个时间格式(2022-5-4 9:09:54)---字符串转为--时间元组
 #{4}time.mktime(tuple):将时间元组-转换-秒数

 {5}time.localtime：以struct_time类型来输出本地时间

 {6}time.strftime()：将字符串--时间

 {7} time.strftime("%Y-%m-%d-%H_%M_%S", time_loc)

(4)自定义模块

【1】知识点

#{1}调用模块的方法
 print("{1}调用模块的方法:")
 module_demo.module_show()#调用模块的方法
#{2}调用模块中类--的属性和方法
print("{2}调用模块中类--的属性和方法")
module=module_demo.Module_demo("小张",123)#调用模块的类
print(module.age)#调用模块里类的属性
 module.model_show()##调用模块里类的方法

【2】方法

#(4)自定义模块
#[1]import
# import module_demo#导入自定义类
# #{1}调用模块的方法
# print("{1}调用模块的方法:")
# module_demo.module_show()#调用模块的方法
# #{2}调用模块中类--的属性和方法
# print("{2}调用模块中类--的属性和方法")
# module=module_demo.Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法

# # [2]form---import
# from module_demo import Module_demo#从自定义模块中，导入Module_demo类
# module=Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法
#
# # [3]对导入的模块--起别名
# import module_demo as mod_d
# #{1}调用模块的方法
# mod_d.module_show()#调用模块的方法
# #{2}调用模块中类--的属性和方法
# module=mod_d.Module_demo("小张",123)#调用模块的类
# print(module.age)#调用模块里类的属性
# module.model_show()##调用模块里类的方法

#[4]开发中--用代码--创建文件
# import sys
# print("{1}sys.path:获取文件地址")
# print(sys.path)
# print("{2}sys.path.append():将自定义的模块，添加到sys.path的路径中")
# sys.path.append("C:\\Users\\DELL\\PycharmProjects\\dom02")
# print(sys.path)
# import module_demo#导入自定义类
# module_demo.module_show()#调用模块的方法

云心截图：
#[4]开发中--用代码--创建文件

(5)模块的导入特性

#(5)模块的导入特性
#[1]__all__
from calc import *
print(add(1,2))
print(subtract(2,1))
print(multiply(1,2))

#[2]__name__:用于代码测试,{1}类似junit{2}当__name__ == "__main__"时，运行代码时才会执行if里的代码
from calc import *
if __name__ == "__main__":
    print(add(1,2))
    print(subtract(1, 2))
    print(multiply(1, 2))
    print(divide(1, 2))
else:
    print(__name__)

云心截图：

 

 

第9章：文件与文件路径的操作

1.1：文件的打开和关闭

(1)文件打开

# open('txt_file.txt',mode='r',encoding="utf-8")

(2)关闭文件

# txt_open01.close()#关闭字节

(3)打开文件的搭配模式

 1.2:从文件中读取数据

--文件的读取

（1）read()按字节读取

#[1]read(要读取file的字节个数size)
# txt_open01=open('txt_file.txt',mode='r',encoding="utf-8")
# print('读取2个字节：')
# print(txt_open01.read(2))#表示读取2个字节
# txt_open01.close()#关闭字节
#
# # [2]read():读取文件的全部2字节
# txt_open02=open('txt_file.txt',mode='r',encoding="utf-8")
# print("读取全部的字节：")
# print(txt_open02.read())
# txt_open02.close()#关闭字节

# #[3]readline():按行读取文件的内容(推荐用这个)
# txt_open03=open('txt_file.txt',mode='r',encoding="utf-8")
# while True:
#     tem=txt_open03.readline()
#     if tem =="":
#         break
#     print(tem)
# txt_open03.close()

# #[4]readlines():一次性读取所有的行
# txt_open04=open('txt_file.txt',mode='r',encoding="utf-8")
# print(txt_open04.readlines())
# txt_open04.close()

--向文件写入数据

（2）write写入

# #[1]write()
# txt_write01=open('txt_file.txt',mode='w',encoding="utf-8")
# print(txt_write01.write("111111111111"))

# #[2]writelines():向文件写入字符窜序列
# txt_write02=open('txt_file.txt',mode='w',encoding="utf-8")
# print(txt_write02.writelines(["22222"]))

（3）文件打开搭配的模式

# 注意：
# 1不管是读取，还是写入指针都会移动
# 2读取和写入后都要：恢复指针到初始位置--txt_read_03.seek(0, 0)
# 3获取指针的位置---txt_read_03.tell()

# [1]open(mode='a'):a 向文件追加内容，不能读
# txt_a01=open('txt_file.txt',mode='a',encoding="utf-8")
# print(txt_a01.write("111111111111"))

# [2]open(mode='r+'):可读可写，但是若文件不存在，则调用失败
# txt_read_01=open('txt_file.txt',mode='r+',encoding="utf-8")
# print("写入前指针的位置在：",txt_read_01.tell())
# txt_read_01.write("3[2]open(mode='r+')")
# print("写入后指针的位置在：",txt_read_01.tell())
# print(txt_read_01.read())
# print("写入后，再读取后指针的位置在：",txt_read_01.tell())
# txt_read_01.close()

#[3]open(mode='w+'):可读可写，若文件已存在，则重写文件
# txt_read_03=open('txt_file.txt',mode='w+',encoding="utf-8")
# print("写入前指针的位置在：",txt_read_03.tell())
# txt_read_03.write("3[3]open(mode='w+')")
# print("写入后指针的位置在：",txt_read_03.tell())
# print("所以要重置指针")# 回复文件指针到初始位置(重点，容易出错)
# txt_read_03.seek(0, 0)
# print("从头开始打印了",txt_read_03.read())
# txt_read_03.close()

#[4]open(mode='a+'):可读可写，但只允许在文件的末尾添加数据，若文件不存在，则创建新文件
# txt_read_04=open('txt_file.txt',mode='a+',encoding="utf-8")
# print("写入前指针的位置在：",txt_read_04.tell())
# txt_read_04.write("3[4]open(mode='a+')")
# print("写入后指针的位置在：",txt_read_04.tell())
# print("所以要重置指针")# 回复文件指针到初始位置(重点，容易出错)
# txt_read_04.seek(0, 0)
# print("从头开始打印了",txt_read_04.read())
# txt_read_04.close()

1.3：文件的定位读取

（1）文件定位

#（1）文件定位
# [1]tell()
# file=open("new_file.txt",mode='r',encoding='utf-8')
# print(file.read(7))#读取内容
# print(file.tell())#输出文件的读取的位置

#[2]seek():设置当前文件读/写位置
# {1}seek(15,0):#从开始位置，偏移15个字节后，从哪开始读取
# file01=open("new_file.txt",mode='r',encoding='utf-8')
# file01.seek(15,0)#从开始位置，偏移15个字节后，从哪开始读取
# print("指针要读取的位置：",file01.tell())
# print(file01.read())
# print("使指针恢复到开始位置")
# file01.seek(0,0)#使指针恢复到开始位置
# print("指针的位置：",file01.tell())
# file01.close()

1.4：文件复制与重命名

#（2）文件复制与重命名
# 【1】文件复制
# file_name="new_file.txt"
# source_file=open(file_name,mode='r',encoding='utf-8')#打开文件
# all_data=source_file.read()#读取所有内容
# flag=file_name.split(".")
# new_file=open(flag[0]+"备份"+".txt",mode="w",encoding="utf-8")#创建新文件
# new_file.write(all_data)#写入数据
# source_file.close()#关闭source_fil读取文件流
# new_file.close()#关闭写入流

# 【2】文件重命名
# import os
# os.rename("txt_file.txt","new_file.txt")#旧的文件名，新的文件名

1.5：目录操作

# (1)目录操作
# [1]创建目录
# 创建目录:os.mkdir(dir_path),在os包下
# import os#os.mkdir(dir_path)
# dir_path=input("亲输入目录")
# yes_or_no=os.path.exists(dir_path)#判断目录是否存在，并返回True/File
# #判断目录是否存在
# if yes_or_no is False:
#     os.mkdir(dir_path)#创建目录
#     print("该执行代码的运行路径：",os.getcwd())
#     new_file=open(os.getcwd()+'\\'+dir_path+'\\'+"new_file.txt",'w',encoding='utf-8')#写入指定的文件目录，再通过w模式，若文件不存在，会自动创建
#     new_file.write('老表进去了')#写入内容
#     print("写入成功")
#     new_file.close()
# else:
#     print("该目录已存在")

#[2]删除目录:rmtree()
# 删除目录:rmtree(),在shutill包下
# import os
# import shutil#删除目录:rmtree()
# yes_or_no=os.path.exists("test02")#第1次判读目录是否存在
# print(yes_or_no)
# if yes_or_no == True:
#     shutil.rmtree("test02")#执行删除操作
#     print("删除成功")
# else:
#     print("删除失败")

#[3]获取目录文件的文件列表
#os包下--listdir():用于获取该文件夹下文件，或，文件夹名的列表（该列表以字母顺序排序）
#listdir(path)
# import os
# current_path=r"D:\python项目"
# print(os.listdir(current_path))

1.6：文件路径操作

#(1)文件路径操作
#[1]相对路径和绝对路径
#{1}isabs()函数:os包提供的，功能；测试目标路径是否为绝对路径
# import  os
# print(os.path.isabs("new_file.txt"))#相对路径
# print(os.path.isabs("D:\python项目\\txt.txt"))#绝对路径

#{2}abspath():os包提供的，功能：将相对路径-规范为-绝对化
# import  os
# print(os.path.abspath("new_file.txt"))#将相对路径-规范为-绝对化
# print(os.getcwd())#获取该执行文件的当前路径

#[2]获取当前路径
#os.getcwd()
# import  os
# print(os.getcwd())

#[3]检查路径的有效性
#os包下的exists():判断路径是否存在，若存在返回True，不存在返回Flase
# import os
# current_path="D:\python项目"
# current_path_file="D:\python项目\\txt.txt"
# print(os.path.exists(current_path))
# print(os.path.exists(current_path_file))

#[4]路径的拼接
#os.path.join(path1,path2[,...]):将path1和path2进行路径拼接
#{1}join()将路径“python项目”和“python_path”进行拼接
# import  os
# path_one='D:python项目'
# path_two='python_path'
# #window系统下使用“\”分隔路径
# splici_path=os.path.join(path_one,path_two)
# print(splici_path)

#{2}若最后一个路径为空，则生成的路径以为一个“\”结尾
# import os
# path_one="D:python项目"
# path_two=''
# splici_path=os.path.join(path_one,path_two)
# print(splici_path)

第10章:错误与异常

1.1：错误和异常概论

(1)捕获异常

#【1】捕获所有异常
# try:
#     dom_list=["1","2","3","4"]
#     print(dom_list[5])
# except Exception as e:
#     print("异常：",e)

#[2]else：只有try里的内容为正确时，才执行else里的语句
# num=input("亲输入数字")
# try:
#     num_input=float(num)#进行数据类型的转换
# except Exception as e:
#     num_input=20#若转化出错，则使用预设的数据量
#     print("当前页面的显示：{0}条数据".format(num_input))
# else:#只有try里的数据转换正确才执行
#     print("当前页面的显示：{0}条数据".format(num_input))

#【3】finally最终语句，不管try是否正确，都执行
# num=input("亲输入数字")
# try:
#     num_input=float(num)#进行数据类型的转换
# except Exception as e:
#     num_input=20#若转化出错，则使用预设的数据量
#     print("当前页面的显示：{0}条数据".format(num_input))
# finally:#最终语句，不管try是否正确，都执行
#     print("当前页面的显示：{0}条数据".format(num_input))

1.2：抛异常

(2)抛出异常

#[1]raise:主动抛出异常:
# {1}raise的功能：
#   1类似java中的throws，先上抛异常，
#   2与if-else连用，常用于自定义异常
# {2}raise的方式：
#   1有异常类名引发异常
#   2由异常对象引发异常
#   3由陈序中出现过的异常引发异常

#[1]使用类名引发异常
#自定义异常类
# class FileTypeErrot(Exception):
#     def __init__(self,err="仅支持jpg/png/bmp格式"):
#         super().__init__(err)
#调用异常类
# file_name=input("请输入上传图片的名称格式：")
# try:
#     if file_name.split(".")[1] in ["jpg","png","bmg"]:
#         print("上传成功")
#     else:
#         raise FileTypeErrot()#使用类名引发异常
# except Exception as e:
#     print(e)

#[2]由异常对象引发异常
# #自定义异常类
# class FileTypeErrot(Exception):
#     def __init__(self,err="仅支持jpg/png/bmp格式"):
#         super().__init__(err)
# #调用异常类
# file_name=input("请输入上传图片的名称格式：")
# try:
#     if file_name.split(".")[1] in ["jpg","png","bmg"]:
#         print("上传成功")
#     else:
#         file_error=FileTypeErrot()
#         raise file_error#使用类名引发异常
# except Exception as e:
#     print(e)

#[3]由异常引发异常(一般不用)
#自定义异常类
# class FileTypeErrot(Exception):
#     def __init__(self,err="仅支持jpg/png/bmp格式"):
#         super().__init__(err)
# #调用异常类
# file_name=input("请输入上传图片的名称格式：")
# try:
#     if file_name.split(".")[1] in ["jpg","png","bmg"]:
#         print("上传成功")
#     else:
#         try:
#             raise FileTypeErrot()#使用类名引发异常
#         except Exception as e:
#             raise
# except Exception as e:
#     print(e)

(3)异常的传递

#[1]默认异常传递会抛给上一级，若上一级没有处理，会继续向上传递，直到异常被处理或程序崩溃
#   {1}一般异常传递是通过函数来传递的
#   {2}通过函数的返回值来传递异常，直到抛给有写到try-excpt的函数中

# def get_num():#计算边长
#     print("开始执行get_num()")
#     num=input("亲输入除数：")
#     width_len = 10/float(num)
#     print("get_num()执行结束")
#     return width_len
#
# def calc_area():#计算正方形面积
#     print("calc_area()开始执行")
#     width_len=get_num()
#     print("calc_area()执行完毕")
#     return width_len*width_len
#
# def show_area():#数据显示
#     try:
#         print("show_area()开始执行")
#         area_val=calc_area()
#         print("正方形的面积为{0}".format(area_val))
#         print("show_area()执行结束")
#     except Exception as e:
#         print("捕获到异常为：{0}".format(e))
#
# #执行函数show
# show_area()

#(4)assert断言语句
# age=float(input("亲输入您的年龄"))
# assert age >= 18,"年龄必须大于18岁才能跟大哥喝酒。。。"
# print("我可以去喝酒了")

1.3:自定义异常

(5)自定义异常

# # 自定义异常类
# class FileTypeErrot(Exception):
#     def __init__(self,err="仅支持jpg/png/bmp格式"):
#         super().__init__(err)
# # 调用异常类
# file_name=input("请输入上传图片的名称格式：")
# try:
#     if file_name.split(".")[1] in ["jpg","png","bmg"]:
#         print("上传成功")
#     else:
#         raise FileTypeErrot()#使用类名引发异常
# except Exception as e:
#     print(e)

#(6)with语句与上下文管理器
#[1]python内置的with():
#功能：{1} 代替finally语句去关闭文件
#       {2}不管文件打开是否成功，with都会关闭资源

# with open("with_file.txt",mode="r",encoding="utf-8") as file:
#     for item in file:
#         print(item)

#[2]自定义上下管理器
class OpenOperation:
  def __init__(self,path,mode):
      #记录要操作的文件路径和模式
      self.__path=path
      self.__mode=mode
  def __enter__(self):#打开文件
      print("代码执行到__enter__")
      self.__handle=open(self.__path,self.__mode)
      return self.__handle
  def __exit__(self, exc_type, exc_val, exc_tb):#关闭文件
      print("代码执行到__exit__")
      self.__handle.close()

#执行函数
with OpenOperation("自定义上下文管理.txt","w+") as file:
  #创建写入文件
  file.write("6666666666666666666")
  print("写完文件了")