第四天 函数和面向对象
学习项目及练习源码地址：GitHub源码
函数
Python中的函数必须先定义才能调用。
Python中函数的分类
-
内置函数
内置函数对象在解释器运行时会自动创建。前面用到的len(),sorted()等都是内置函数。
-
标准库函数
标准函数在import模块时，解释器会执行模块中的def语句。
别个整理的一个标准库思维导图：
标准库
-
第三方库函数
第三方库函数对象创建和标准库一致，在import模块时创建。
别个整理的一个常用三方库思维导图:
三方库思
-
自定义函数
用def关键字创建一个函数
在Python中函数也是一个对象！Python中，定义函数的语法如下:
def 函数名([参数列表]): # 无形参函数须保留()
'''函数说明文档''' # 函数说明性注释是一个好习惯， help(函数名.__doc__)可以打印输出函数的文档说明
函数体
[return]
# 如果函数体中包含return语句，则结束函数执行并返回值;
# 缺省返回None
# 使用列表、元组、字典、集合等返回多个值
不需要指定函数返回类型。
def printStars(n):
'''
打印小星星
'''
print('*' * n)
print(id(printStars)) # 4564978720 函数也是一个对象
print(type(printStars)) # <class 'function'>
print(printStars) # <function printStars at 0x110180c20>
help(printStars.__doc__) #查看函数文档
printStars(5) # *****
printStars(10) # **********
c = printStars # 一切都是对象。通常情况下不需要这样做，举例说明不要忘记()，否则就是赋值操作了。
print(id(c)) # 4564978720
c(5) # *****
c(10) # **********
函数的参数
-
形参和实参原则上应该个数一致
定义函数时，多个形参用,号分开，不需要指定参数类型。
-
一切对象都可以作为参数传递
序列：字典，列表...函数，类等等都可以作为参数传递。
-
Python中参数的传递都是“引用传递”
-
传递一个可变对象
字典、列表、集合、自定义的对象等。
在函数内部所有对该类型变量的操作，都会修改外部实参对象的结果。
-
传递一个不可变对象
数字、字符串、元组、布尔值、function等
在函数内部对该类型变量进行“赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象并引用到该变量。在赋值操作之前，该变量依然是原对象的引用。
a = [1,2,3] # 可变 b = 100 # 不可变 def test(m,n): print(id(m)) # 4414439168 和 a地址一样 print(id(n)) # 4393233264 和 b地址一样 m.append(4) n += 1 print(id(m)) # 4414439168 没有变化 print(id(n)) # 4393233296 新的对象 print(m) # [1, 2, 3, 4] print(n) # 101 print(id(a)) # 4414439168 print(id(b)) # 4393233264 test(a,b) print(a) # [1, 2, 3, 4] 变化了 print(b) # 没有变 -
传递不可变对象时发生拷贝属于浅拷贝
-
浅拷贝
不拷贝子对象的内容，只是拷贝子对象的引用
-
深拷贝
会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
传递不可变对象包含的子对象是可变对象
方法内修改了这个可变对象，源对象也发生了变化。掌握浅拷贝和深拷贝的要点。在进行参数传递时，根据需要考虑传递什么方式的拷贝参数。
-
-
-
参数定义的几种类型
-
位置参数
函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为: “位置参数”。
传递个数不匹配时将引发异常。
-
带有默认值的参数
定义函数时，可以为某些参数设置默认值，这样这些参数在传递时就是可选的。称为“默认值参数”。 默认值参数放到位置参数后面。
-
参数命名传递
在函数调用时，可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”。这样可以不用按照函数定义时参数的位置进行函数调用。
-
可变参数
在函数定义时，可以定义可变参数。
-
*param(一个星号)，将多个参数收集到一个“元组”对象中。
-
**param(两个星号)，将多个参数收集到一个“字典”对象中。
可变参数一般定义在形参的最后一个位置。
-
-
强制命名参数
如果定义函数时，非要在“可变参数”后面增加新的参数，必须在调用的时候强制使用“命名参数”方式进行函数调用，否则会引发异常。
-
变量和变量的作用域
变量起作用的范围称为变量的作用域，不同作用域内同名变量之间互不影响。在Python中变量分为:全局变量、局部变量。
-
全局变量
- 定义在模块中，函数和类之外的变量就是全局变量。作用域为定义的模块，从定义位置开始直到模块结束。
- 应尽量避免全局变量的使用。影响通用性和阅读性。
- 一般将常量定义成全局变量。
- 函数内要改变全局变量的值，使用global声明一下。
-
局部变量
- 定义在函数内部的变量，包括形参
- 类里面还有类变量
- 局部变量的引用速度比全局变量快
- 局部变量和全局变量同名，函数体内优先使用
- 函数在执行时解释器会创建栈桢（stack frame),局部变量名存放在栈桢中（对象依然放在堆中），函数执行完毕时，栈桢回收。
- locals()查看局部变量
- globals()查看全局变量
-
效率建议
- 模块中import的函数或类属于全局变量
- 复杂的循环运算时，将全局变量转换成局部变量进行运算
import math def test(): b = math.sqrt # 转成局部变量 for x in range(10000000): b(300) -
lambda表达式和匿名函数
lambda表达式可以用来声明匿名函数。lambda函数是一种简单的、在同一行中定义函数 的方法。lambda函数实际生成了一个函数对象。lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。
lambda 表达式的基本语法如下:
lambda arg1,arg2,arg3... : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是:表达式的运算结果。
fn = lambda x,y,z:(x+y)*z print(type(fn)) # <class 'function'> fn(1,2,3) # 9 a = (lambda z:z**3,lambda z:z+z,lambda z,n:z*n) #将lambda表达式作为元祖的元素 b = (a[0](3),a[1](4),a[2]('*',10)) print(b) # (27, 8, '**********') -
eval()函数
不想看这个，一般都不建议使用
-
递归函数
在Python中，递归函数会创建大量的函数对象，导致过量的消耗内存和运算能力。在处理大量数据时，谨慎使用。阶乘练习源码
-
嵌套函数
顾名思义，在函数内部定义的函数的方式叫嵌套函数。
-
封装 - 数据隐藏
外部无法访问“嵌套函数”。
-
DRY原则
嵌套函数，可以让我们在函数内部避免重复代码。
-
闭包
-
使用关键字nonlocal在嵌套函数中使用外层函数的变量，和global一样的原理。
**LEGB规则：Local-->Enclosed-->Global-->Built in**
如果某个变量名映射在局部(local)命名空间中没有找到，接下来就会在闭包作用域(enclosed)进行搜索，如果闭包作用域也没有找到，Python就会到全局(global)命名空间中进行查找，最后会在内建(built-in)命名空间搜索(如果一个名称在所有命名空间中都没有找到，就会产生一个NameError)。
小结
在Python中函数的定义和大部分变成语言道理是一样的，注意函数返回值问题，这个和Java、C++等不太一样。参数的定义和传递也有差异。命名参数调用函数比较特别，也非常有用。掌握可变参数的出传递和使用。
-
练习
输入三角形三个顶点的坐标，若有效则计算三角形的面积;如坐标无效，则给出提示。
练习源码遇到很多坑，填了，可以自己先写写再看。
Python中面向对象编程
不解释什么是面向对象或面向对象编程，以及不解释什么是面向过程或面向过程编程。请君在google百度一下相关概念。
类的定义
记住：Python中“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。
定义类的语法格式如下:
class 类名: # 建议首字母大写的驼峰命名规则，如：ArrayList
类体
类是抽象的，也称之为“对象的模板”。需要通过类这个模板，创建类的实例对象，然后才能使用类定义的功能。当解释器执行class语句时，就会创建一个类对象。
-
__init__()类的构造函数
构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
- 在Python中构造函数名称是固定的必须是init()
- 第一个参数必须是self,指向对象本身，参数名预定成俗就是self.
- 构造函数通常用来初始化实例对象的实例属性
- 不定义init方法，系统会提供一个默认的init方法。如果我们定义了带参的init方法，系统不创建默认的init方法。
-
__new__()用于创建对象，一般不需要重定义
-
类的调用方法
myObj = ClassName([构造参数])
类的实例属性和实例方法
-
实例属性
实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点:
-
实例属性一般在init()方法中通过如下代码定义:
self.实例属性名 = 初始值不能写return,默认返回的是实例化好的对象。
-
在类的其他实例方法中，通过self进行访问:
self.实例属性名 -
创建实例对象后，通过实例对象访问:
obj01 = 类名() #创建对象，调用__init__()初始化属性 obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性
-
-
实例方法
实例方法是从属于实例对象的方法。实例方法的定义格式如下:
def 方法名(self [, 形参列表]): 函数体 #方法的调用格式如下: 对象.方法名([实参列表])- 定义实例方法时，第一个参数必须为self。self指当前的实例对象。
- 调用实例方法时，不需要也不能给self传参。self由解释器自动传参。
-
dir(obj)可以获得对象的所有属性、方法
-
obj.__dict__ 对象的属性字典
-
pass空语句
-
isinstance(对象,类型)判断“对象”是不是“指定类型”
class Test:
def __init__(self,name,age): # self必须的
self.name = name
self.age = age
def getMyName(self): # self必须的
return self.name
def getMyAge(self):
return self.age
testObj = Test("张三",18) # 调用类，实例化一个”实例对象“
print(id(Test)) # 140614954454304
print(Test) # <class '__main__.Test'>
print(type(Test)) # <class 'type'>
print(id(testObj)) # 4340153616
print(type(testObj)) # <class '__main__.Test'>
print(testObj.getMyName())
print(testObj.getMyAge())
print(Test.getMyName(testObj)) # 解释器是这个干的，方法是共享的
print(dir(Test))
'''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'getMyAge', 'getMyName']
'''
print(dir(testObj))
'''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'getMyAge', 'getMyName', 'name']
'''
# 多了name 和 age
print(Test.__dir__) # <method '__dir__' of 'object' objects> 注意类是objects的对象
print(testObj.__dir__) # <built-in method __dir__ of Test object at 0x109bf3e90>
print(isinstance(testObj,Test)) # True
实例对象和类对象共享类方法。
类对象、类属性、类方法、静态方法
-
类对象
解释器遇到class关键字时就创建了一个类对象。
-
类属性
类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。
类属性的定义方式:
class 类名: 类变量名 = 初始值在类中或者类的外面，我们可以通过:“类名.类变量名”来读写。
-
类方法
类方法是从属于“类对象”的方法。
类方法通过装饰器@classmethod来定义，格式如下:
@classmethod def 类方法名(cls [，形参列表]): 函数体- @classmethod必须位于方法上面一行
- 第一个参数：cls必须有;cls指的就是“类对象”本身;
- 调用类方法格式:“类名.类方法名(参数列表)”。参数列表中，不需要也不能给cls传值。
- 类方法中访问实例属性和实例方法会导致错误
- 子类继承父类方法时，传入cls是子类对象，而非父类对象
-
静态方法
“类对象”无关的方法，称为“静态方法”。“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。
静态方法通过装饰器@staticmethod 来定义，格式如下:
@staticmethod def 静态方法名([形参列表]): 函数体要点如下:
- @staticmethod必须位于方法上面一行
- 调用静态方法格式:“类名.静态方法名(参数列表)”
- 静态方法中访问实例属性和实例方法会导致错误
del方法(析构函数)和垃圾回收机制
del方法称为“析构方法”，用于实现对象被销毁时所需的操作。
Python实现自动的垃圾回收，当对象没有被引用时(引用计数为 0)，由垃圾回收器调用del方法。可以通过del语句删除对象，从而保证调用del方法。系统会自动提供del方法，一般不需要自定义析构方法。
call方法和可调用对象
定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
方法重载
Python方法没有重载!!!
类体中定义了多个重名的方法，只有最后一个方法有效。
**可以根据参数的动态性或参数的可变性，实现一个方法的多种用途。**
方法的动态性
Python是动态语言，可以动态的为类添加新的方法，或者动态的修改类的已有的方法。
class Test:
def __init__(self,name):
self.name = name
def add(self,a,b):
print("old method:{0} {1}".format(a+b,self.name))
def count(obj):
print("count {}".format(obj.name))
def add(obj,a,b):
print("new method:{0} {1}".format(a+b,obj.name))
test = Test('zhangsan')
test.add(1,2)
Test.count = count
test.count()
Test.add =add
test.add(11,22)
私有属性和私有方法
Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点:
- 通常约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
- 类内部可以访问私有属性(方法)
- 类外部不能直接访问私有属性(方法)
- 类外部可以通过“类名_私有属性(方法)名”访问私有属性(方法)
方法本质上也是属性!只不过是可以通过()执行而已。所以，私有方法和私有属性是一样的。
class Test:
__address = '上海1弄1号'
def __init__(self,name):
self.name = name
self.__age = 29
self.__address = "上海100弄1号"
def __mockAge(self):
print("my age is {}".format(18))
def getAge(self):
self.__mockAge()
def __realAge(self):
print("my age is {}".format(self.__age))
test = Test("张三")
print(test._Test__age)
test.getAge()
test._Test__realAge()
print(Test._Test__address) # 和对象属性重复怎么办？注意调用者
@property装饰器
@property可以将一个方法的调用方式变成“属性调用”。只能调用，但不能设置值。要修改值需要用 @salary.setter装饰一个同名方法，才能进行设置。
class Test:
def __init__(self):
self.__age = 18 # 不能直接访问了
@property
def age(self):
return self.__age
@age.setter
def age(self,n):
if n > 100 or n < 0:
print("age must in [0-100]")
return
self.__age = n
test = Test()
myAge = test.age
print('my age is:{}'.format(myAge))
test.age = 300
myAge = test.age
print('my age is:{}'.format(myAge))
test.age = 50
myAge = test.age
print('my age is:{}'.format(myAge))
小结
时间过得太快，今天的就学了这些东西。Python在面向对象编程方面很有创新，但是编程思维和大多数语言一致，只是在应用的时候要好好掌握这些基础的东西，才能用面向对象的思维干活。
下次将进一步学习Python面向对象编程的三大特征：继承，多态，设计模式等...
网友评论