51.函数的文档注释及作用
"""
函数的文档注释:
函数的注释文字.
必须添加到函数定义的那一行的下面一行.
好处:
当使用Ctrl + Q查看函数的使用说明文档时,能够把文档注释自动显示出来.
"""
def sum（）：
“””
打印5行“你好”
“””
for I in range(5)
print(“hello”)
sum()
52. 函数的参数 和 参数传递的过程
"""
给函数指定参数:a和b都是参数
参数的作用:
是用来接收调用函数时传递过来的数据的,可以在函数内部处理这些数据.
给函数设置参数的好处:
让函数变得更加通用,提高的函数的扩展性.
"""
53. 函数的返回值
# 如果函数有返回值,可以直接打印
print(input())
# list.append()方法没有返回值
list.append("a")
# 如果函数没有返回值,直接打印的结果为None,None表示空,就是什么都没有的意思.
print(list.append("a"))
定义一个函数,并且返回一个值.
定义有返回值的函数的格式:
def 函数名(形参1,形参2,...):
函数体
return 返回的数据
这里面return的作用:
把返回的数据 返回到函数的调用处,在哪个地方调用了函数,就把数据返回到哪个地方.
54. print函数 和 return 的区别
在有返回值的函数中,return是用来把返回值返回到函数的调用处的.没有打印的功能.
与print函数没有任何关系,print函数只是用来打印数据的,没有返回数据的功能.
55. 函数的嵌套
在定义一个函数时,在函数的内部调用了另外一个函数.
56. 解包
组包: 把多个数据,组装到一个容器中;
解包(拆包): 把容器中的多个数据拆出来.
57. 局部变量和全局变量
局部变量:在函数内部定义的变量;
使用范围仅限于函数内部,不能再函数外面使用;
全局变量:在函数外部定义的变量;
使用范围是整个程序文件,前提是先定义后使用.
58.通过global关键字修改全局变量的值(修改引用)
要想在函数内部修改全局变量的值:
1.先使用global关键字声明全局变量:
global m
2.修改全局变量的值:
m = 500
59. 引用1-引用的概念和特点
引用:
数据在内存中对应的地址
如果两个变量为同一个引用,那么这两个变量对应的数据一定相同;
如果两个变量对应的数据相同,引用不一定相同;
60. 引用2-数字类型和字符串类型数据的缓存区
在解释器一启动的时候,会把小数字(-5~256)和短字符串(长度小于21)缓存到缓冲区中.
当在程序中使用这些数字和字符串时,就直接从缓存区中取.
61. 函数参数的传递过程
传递数据,传递的是数据对应的地址.
62. 可变类型和不可变类型
可变类型:
如果修改了数据的内容,数据的地址没有发生改变.
有列表,字典,set集合
不可变类型:
如果修改了数据的内容,数据的地址发生改变.
有字符串,元组,数字
63.可变类型的影响
对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量
64. 工具函数-range类型
range(n):
得到0到n之间的数据,包括0,但是不包括n.
n是一个整数.
range(m,n):
得到m到n之间的数据,包括m,但是不包括n.
m,n是一个整数.
65. 列表 推导式
66. 匿名函数
def 函数名(形参列表):
函数体
return 数据
匿名函数:没有函数名的函数.
定义匿名函数的格式:
变量名 = lambda 形参1,形参2,... : 表达式
匿名函数的返回值为 表达式 的值.
匿名函数只能进行简单的逻辑处理.
67. 递归函数
递归函数:
在函数里面自己调用了自己.
开发递归函数的两个条件:
1.在函数内部自己调用自己
2.给递归设置一个终止的条件
递归函数非常耗费,所以以后尽量不要使用递归函数.
在python中递归的层次不能超过1000次.所以在定义递归函数时需要设置一个终止递归的条件.
def func1()
...
func1()
68.面向对象
面向对象概述如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的大中型项目开发场景。面向对象则出现得更晚一些，典型代表为Java或C++等语言，更加适合用于大型开发场景。两种开发思想各有长短。
对于面向过程的思想： 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,需要自己编写代码(自己来做)
对于面向对象的思想：当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)
面向对象的三大特征有：封装性、继承性、多态性。
69.类与对象的关系
我们学习编程语言，就是为了模拟现实世界中的事物，实现信息化来提高工作效率。例如银行的业务系统、超市的结账系统等，都是如此。
面向对象的语言当中，“类”就是用来模拟现实事物的。
那么模拟现实世界的事物通常从两方面模拟：
- 属性：事物的特征描述信息，用于描述某个特征“是什么”。 静
- 行为：事物的能力行动方案，用于说明事物“能做什么”。
类中也有属性、行为两个组成部分，而“对象”是类的具体实例。例如：
- 类：抽象的，是一张“手机设计图”。
- 对象：具体的，是一个“真正的手机实例”。
70. 面向对象的概述
面向过程:
当需要实现一个功能的时候,首先考虑的该如何实现这个功能,考虑的实现的步骤和过程,然后自己亲力亲为来实现.(亲力亲为)
面向对象:
当需要实现一个功能的时候,首先考虑 谁能 实现这个功能,然后就让谁帮你实现. (偷懒,让别人帮我做)
面向对象 是 基于面向过程.
71. 类与对象的关系
要想按照面向对象的思想开发软件,必须先得到一个对象;
要想得到对象,必须要有一个叫做类的东西.
因为程序中的对象 是通过类创建出来.所以必须现有一个类.
类:是用来描述现实世界中的某一类事物;
如何使用类描述某一类事物?
把这一类事物共同的特点都抽取出来,写在类中.
都有 姓名 ,年龄,性别 从静的方面描述的,叫做属性.
都能 吃饭,学习,睡觉 从动的方面描述的,叫做行为.
类 是 通过属性和行为来描述那一类事物.
属性:姓名,年龄,性别
行为:吃饭,学习,睡觉
对象:
就是那一类事物中一个个体.
类与对象的关系:
对象是根据类创建出来的.
按照面向对象的思想开发一个功能:
1.先定义一个类;
2.使用类创建一个对象;
3.调用对象的方法;
72.类的定义格式
class 类名:
方法列表
object 是Python 里所有类的最*父类；
类名 的命名规则按照"大驼峰命名法"；
info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象
73.创建对象
74. 添加和获取对象的属性
75.__init__方法：
Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，__init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。
如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，
如果为了能够在完成自己想要的功能，可以自己定义__init__方法，
所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
在类内部获取 属性 和 实例方法，通过self获取；
在类外部获取 属性 和 实例方法，通过对象名获取。
如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；
但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。
76.__str__魔法方法
魔法方法str:
比较特殊,当打印对象或者把对象转成字符类类型的时候,解释器会自动调用这个方法
这个方法必要有一个返回值:return 字符串数据.
通常在这个方法中返回对象的 属性名和属性值拼接的 字符串.
77.__del__魔法方法
魔法方法del:
比较特殊,对象在即将被销毁的时候,解释器自动调用这个方法.
作用:
不是删除对象,没有删除对象的功能.
是用来做临终遗言的事情的.
78. 属性值可以是一个对象
class FDJ:
...
class Car:
def __init__(self,fdj):
self.fdj = fdj
fdj = FDJ()
c = Car(fdj)
79. 私有属性的定义和使用
class Student:
"""
定义私有属性的格式:
self.__属性 = 属性值
私有的属性名 为 : __属性
私有属性只能在类的里面访问,不能在类的外面访问
"""
def __init__(self,name,age):
self.name = name
if 0 < age < 150:
# 给私有属性赋值
self.__age = age
else:
self.__age = 0
print("传递的年龄不正确...")
"""
为了能够在类的外面给私有属性赋值,得到私有属性的值,
需要在类的里面给这属性添加一对set_xxx(),get_xxx(),xxx是属性名
这个方法的作用:
为了能够在类的外面给私有属性赋值
"""
def set_age(self,age):
if 0<age<150:
# 给私有属性赋值
self.__age = age
else:
print("传递的年龄不正确...")
"""
返回私有属性的值
这个方法的作用:
为了能够在类的外面 得到私有属性的值.
"""
def get_age(self):
return self.__age
def __str__(self):
return "姓名:%s,年龄:%d" % (self.name,self.__age)
s = Student("尼古拉斯.赵四",200)
# 在类的外面直接访问属性,给属性直接赋值
# print(s.age)
# 在类的外面访问私有属性,会报错:AttributeError: 'Student' object has no attribute '__age'
# print(s.__age)
# 这是给对象添加了一个公共的属性__age,赋值为300,无效
# s.__age = 300
# 通过set方法给私有属性赋值
s.set_age(300)
# 通过get方法得到私有属性值
print(s.get_age())
print(s)
80.私有方法
class Student:
def __init__(self,name,age):
self.name = name
self.__age = age
"""
定义私有方法的格式:
def __方法名(self,形参列表):
方法体
特点:
只能类的里面使用:需要通过self方法
"""
def __tanlianai(self):
print("哥哥谈恋爱了....")
def func1(self):
# 在类的里面调用私有方法:需要通过self方法
self.__tanlianai()
def __str__(self):
return "姓名:%s,年龄:%d" % (self.name,self.__age)
s = Student("尼古拉斯.赵四",200)
s.func1()
# 在类的外面不能通过对象直接调用私有方法
# s.__tanlianai()
81. 封装的总结
封装:
1.把数据和方法组合到一起,写到类中;
2.把类中不需要对外暴露的属性和方法隐藏起来;
3.把代码块写到方法中,当别人调用这个方法时,只需要知道这个方法的作用(功能),不要知道具体实现的细节;
封装的好处:
对外暴露功能,隐藏了功能实现的细节,可以提高开发效率;
82. .继承
继承:子类继承父类,子类一旦继承父类,就拥有 了父类中非私有的属性和方法;
继承的格式:
class 子类名(父类名):
...
子类不能继承父类中私有的属性和方法
83.多层继承
"""
多层继承:
一层一层的继承
"""
class A:
def __init__(self,a):
self.a = a
def methodA(self):
print("----------methodA----------")
class B(A):
def __init__(self,a,b):
self.b = b
super().__init__(a)
def methodB(self):
print("----------methodB----------")
class C(B):
def __init__(self,a, b,c):
self.c = c
super().__init__(a,b)
def methodC(self):
print("----------methodC----------")
c = C("A类","B类","C类")
print(c.a)
print(c.b)
print(c.c)
84. 在子类中添加方法
可以在子类中添加方法,目的是为了扩展自己的功能;
85. 子类中重写父类中的方法
"""
重写父类中的方法:
在子类中定义一个与父类中方法重名的方法.
重写方法后,当通过子类对象调用这个方法时,调用的是子类中的重写后的方法.
重写方法的原因:
父类中的方法不能满足子类的需要,但是子类又想保留这个方法的名字.
"""
class Fu(object):
def run_company(self):
print("按照父亲的方式经营公司...")
def method01(self):
print("method01...")
# 子类继承父类
class Zi(Fu):
# 重写父类中的run_company方法
def run_company(self):
print("按照儿子的方式经营公司")
zi = Zi()
# 调用的是重写的方法
zi.run_company()
# 调用的是 从父类中继承过来的方法
zi.method01()
86.在子类中调用父类中被重写的方法
"""
在子类中调用父类中被重写的方法,有三种方式:
方式1:
父类名.方法名(self,形参值的列表)
方式2:
super(子类名,self).方法名(形参值的列表)
方式3:
super().方法名(形参值的列表)
super是父类名.
如果想改进父类中的这个方法,不要直接改.
需要定义一个子类,继承父类,然后重写父类中方法,调用父类中被重写的方法,增加自己的代码.
"""
"""
class Fu(object):
def run_company(self):
print("按照父亲的方式经营公司...")
def method01(self):
print("method01...")
# 子类继承父类
class Zi(Fu):
# 重写父类中的run_company方法
def run_company(self):
print("按照儿子的方式经营公司")
# 在子类中调用父类中被重写的方法
def func1(self):
# 调用子类中重写方法run_company
self.run_company()
# 调用父类中的run_company
# 方式1
# Fu.run_company(self)
# 方式2:
# super(Zi,self).run_company()
# 方式3:
super().run_company()
zi = Zi()
zi.func1()
87. 继承中的两个细节
class Fu(object):
def __init__(self, money, house):
self.money = money
self.house = house
# 私有属性
self.___girl_friend = "青霞"
def run_company(self):
print("按照父亲的方式经营公司...")
# 私有方法
def __xiyu(self):
print("父亲洗浴了...")
#定义了一个公共的方法,在里面调用私有属性和方法
def func1(self):
print("父亲的女朋友:%s" % self.___girl_friend)
self.__xiyu()
# 子类继承父类
class Zi(Fu):
# 给子类添加属性
def __init__(self,money,house,girl_friend):
self.girl_friend = girl_friend
# 调用父类中的init方法,目的是为了给子类对象添加父类中定义的两个属性
super().__init__(money,house)
zi = Zi(200000000,"别墅","vivi")
print(zi.money)
zi.func1()
88. 继承中的两个细节
class Fu(object):
def __init__(self, money, house):
self.money = money
self.house = house
# 私有属性
self.___girl_friend = "青霞"
def run_company(self):
print("按照父亲的方式经营公司...")
# 私有方法
def __xiyu(self):
print("父亲洗浴了...")
#定义了一个公共的方法,在里面调用私有属性和方法
def func1(self):
print("父亲的女朋友:%s" % self.___girl_friend)
self.__xiyu()
# 子类继承父类
class Zi(Fu):
# 给子类添加属性
def __init__(self,money,house,girl_friend):
self.girl_friend = girl_friend
# 调用父类中的init方法,目的是为了给子类对象添加父类中定义的两个属性
super().__init__(money,house)
zi = Zi(200000000,"别墅","vivi")
print(zi.money)
zi.func1()
89. 多继承-调用指定父类中的方法
"""
多继承的格式:
一个子类同时继承了多个父类.
格式:
class 子类名(父类1,父类2,...):
子类的代码
"""
class A:
def __init__(self,a):
self.a = a
def methodA(self):
print("----------methodA----------")
def show(self):
print("----------A类中的show方法----------")
class B:
def __init__(self,b):
self.b = b
def methodB(self):
print("----------methodB----------")
# A类中也有这个方法
def show(self):
print("----------B类中的show方法----------")
# 多继承
class C(A,B):
def __init__(self,a, b,c):
self.c = c
A.__init__(self,a)
B.__init__(self,b)
def methodC(self):
print("----------methodC----------")
#调用A类中的方法
super().show()
# 调用指定父类中的方法:通过第一种方式
B.show(self)
c = C("A类","B类","C类")
print(c.a)
print(c.b)
print(c.c)
c.methodA()
c.methodB()
c.methodC()
# 查看搜索方法的顺序
print(C.mro())
90. 实例属性和实例方法
实例:就是一个对象.
实例化:创建对象.
实例属性:对象的属性.
实例方法:对象的方法.
通过self添加的属性叫做实例属性.
存储在对象中的属性叫做实例属性.
实例方法:
第一个形参是self的方法,就是实例方法.
91. 类对象 类属性
class Student:
...
类属性:所有的对象共享共用的属性,这个属性不专属于某一个对象,是所有的对象共享共用的.
类属性的定义:
定义在类的里面,方法的外面.
如何访问类属性:
1.在类的外面:
类名.类属性名
对象名.类属性名
2.在类的里面:
类名.类属性名
对象名.类属性名
如何修改类属性的值呢?
类名.类属性名 = 修改后的值
92.类方法
class Student:
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def study(self):
print("好好学习,贴图天天向上")
# 在类的里面通过self调用类方法
# self.close("王五")
# 在类的里面通过类名调用类方法
Student.close("王五")
"""
方法的中的cls参数值是当前的类对象,其实就是Student
当调用这个方法时,解释器会自动把类对象传递给cls
在这个方法中无法访问实例属性和实例方法,因为无法得到self.
"""
@classmethod
def close(cls,name):
print(cls)
print(name)
print("最后一个同学关灯...")
# 调用类方法
cls.test()
@classmethod
def test(cls):
print("test...")
s1 = Student("zhangsan",30,"男")
# 在类的外面通过对象名调用类方法:对象名.类方法(形参值的列表)
# s1.close("zhangsan")
# 在类的外面通过类名调用类方法:对象名.类方法(形参值的列表)
# Student.close("李四")
s1.close("李四")
92.静态方法
class Student:
kongtiao = "格力空调"
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def study(self):
print("好好学习,贴图天天向上")
# 在类的里面通过self调用类方法
# self.close("王五")
# 在类的里面通过类名调用类方法
Student.close("王五")
"""
可以在这个方法中通过cls访问类属性类方法
"""
@classmethod
def close(cls,name):
print(cls)
print(name)
print("最后一个同学关灯...")
@staticmethod
def show():
# 通过类名访问类属性和非方法
print(Student.kongtiao)
Student.close("赵六")
s1 = Student("zhangsan",30,"男")
#通过对象调用静态方法
s1.show()
#通过类名调用静态方法
Student.show()
93. __new__方法
class Student:
"""
这个方法是用来创建对象的.
当创建对象时,解释器会自动调用这个方法创建一个空白对象.
如何创建对象的?
通过调用object类中的new方法创建的,创建出来的是一个空白对象,然后返回对象.
"""
def __new__(cls, *args, **kwargs):
return super().__new__(cls)
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def study(self):
print("好好学习,贴图天天向上")
s1 = Student("zhangsan",30,"男")
print(s1.name)
94. 单例的设计模式(了解)
设计模式:
为了解决某一类的问题而设计出来的一种方案.
单例:
在系统中这个类只有一个实例对象.
不管创建对象创建了几次,在系统中始终只有一个对象.
95. 异常的概述
异常:执行程序时程序抛出的红色信息.
异常类是用来描述某一类异常的.
程序中出现的异常需要处理,如果不处理会影响后续代码的执行.
96. 处理异常的基本格式
基本格式:
try:
可能会出现异常的代码块
exept :
处理异常的代码块
处理异常并不能消灭异常不让异常出现,只是捕获住这个异常,不让它影响后面代码的执行.
97.自定义异常类
原因:
1.解释器自带的异常类不能满足我们的需要.
2.解释器自带的异常类不容易学习.
自定义异常类:
1.继承异常父类
2.重写init方法
98. 异常处理中抛出自定义异常
"""
自定义异常类:
1.继承父类
2.重写init方法
"""
class AgeError(Exception):
def __init__(self,msg):
self.msg = msg
class Student:
def __init__(self,name,age):
self.name = name
self.__age = age
def set_age(self,age):
if 0<age<150:
self.__age = age
else:
# 抛出年龄错误的异常:
raise AgeError("年龄必须在0到150之间...")
s = Student("zhangsan",28)
try:
s.set_age(200)
except AgeError as e:
print(e)
99. 包
包:就是工程目录下面的一个文件夹.
包的作用:
对程序文件进行分类管理的.
包的命名规则:
1.可以使用多个单词组成,单词之间不要有间隔;
2.尽量使用一个单词作为包名,一般都是使用功能模块名字的英文缩写;
100.多态
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态 ，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
鸭子类型：虽然我想要一只"鸭子"，但是你给了我一只鸟。 但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。
Python的多态，就是弱化类型，重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确。