python入门知识点（下）

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.类与对象的关系

我们学习编程语言，就是为了模拟现实世界中的事物，实现信息化来提高工作效率。例如银行的业务系统、超市的结账系统等，都是如此。

面向对象的语言当中，“类”就是用来模拟现实事物的。

那么模拟现实世界的事物通常从两方面模拟：

1. 属性：事物的特征描述信息，用于描述某个特征“是什么”。 静
2. 行为：事物的能力行动方案，用于说明事物“能做什么”。

类中也有属性、行为两个组成部分，而“对象”是类的具体实例。例如：

1. 类：抽象的，是一张“手机设计图”。
2. 对象：具体的，是一个“真正的手机实例”。

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的多态，就是弱化类型，重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确。