第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("写完文件了")
153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
