您的位置：首页 > 编程语言 > Python开发

Python之路_Day8

2016-06-29 15:20 309 查看
Python之路_Day8_课堂笔记前期回顾
本期内容一、作业
要点：
二、上节内容回顾和补充
面向对象三大特性：
多态
三、面向对象中成员
字段方法属性
四、成员修饰符五、特殊成员
__init____doc____call____setitem__...
六、面向对象其他知识
- isinstance- issubclass- 继承 2.7- 应用：
自定义类型，对字典进行补充，有序字典
源码的扩展
七、异常处理八、设计模式之单例模式
类方法静态方法
一、作业
要点：
1、封装，对象中嵌套对象2、pickle，load：切记，一定要先导入相关的类

二、上节内容回顾和补充
面向对象基本知识：
1、类和对象的关系2、三大特性：
封装


继承


3、多态：多种形态，多种类型python的多态def func(arg):
print(arg)
func(1)func("sandler")func([11,22,33])
C#/Java的多态def func(int arg):
print(arg)
func(123)func("sandler")# 报错



三、面向对象中类成员
1、字段
class Foo:
# 字段（静态字段）
CC = 123
def __init__(self):
# 字段（普通的字段）
self.name = 'sandler'
def show(self):
print(self.name)



#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler



class Province:

country = '中国'

def __init__(self,name):

self.name = name


hn = Province('河南')

print(hn.name)

print(Province.country)

print(hn.country)

[/code]
一般情况下，自己访问自己的字段规则：
普通字段只能用字段访问静态字段用类访问（万不得已的时候可以使用对象访问）
PS：静态字段在代码加载时已经创建
2、方法
所有的方法属于类普通方法，有对象去调用执行（方法属于类）
至少一个self，通过对象执行
静态方法，由类调用执行
任意参数，由类执行（对象执行）
类方法，由类调用执行
至少一个cls，类执行（对象执行）
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler



class Province:

country = '中国'


def __init__(self,name):

self.name = name

# 普通方法，由对象去调用执行（方法属于类）


def show(self):

print(self.name)


@staticmethod

def f1(arg1,arg2):

# 静态方法是有类调用执行（当方法内部不需要对象中封装的值时，可以将方法携程静态方法）

print(arg1,arg2)


@classmethod

def f2(cls):

# 类方法，由类执行

print(cls)


Province.f1(11,22)

Province.f2()

[/code]
3、属性
属性是个不伦不类的东西具有方法的写作形式，具有字段的访问形式，
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Pager:


def __init__(self,all_count):

self.all_count = all_count


@property

def all_pager(self):

a1,a2 = divmod(self.all_count , 10)

if a2 == 0:

return a1

else:

return a1 + 1


@all_pager.setter

def all_pager(self,value):

print(value)


@all_pager.deleter

def all_pager(self):

print('del all_pager')



p = Pager(101)

ret = p.all_pager

print(ret)  # 获取


p.all_pager = 111   # 设置


del p.all_pager # 删除

[/code]


属性的另一种表达方式：
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler



class Pager:


def __init__(self,all_count):

self.all_count = all_count


def f1(self):

return 123


def f2(self,value):

pass


def f3(self):

pass


foo = property(fget=f1,fset=f2,fdel=f3)


p = Pager(101)


result = p.foo

print(result)   # 自动调用f1


p.foo = 'sandler'   # 自动调用f2


del p.foo   # 自动调用f3

[/code]





四、类成员修饰符
公有：
内部和外部都可以访问的字段

私有：
只能类自己本身成员可以访问
只有内部可以访问的字段，在字段前加两个下划线表示私有字段，无法继承

#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler

# 成员修饰符


class Foo:

__cc = "123"


def __init__(self,name):

self.__name = name


def f1(self):

print(self.__name)


@staticmethod

def f3():

print(Foo.__cc)


# print(Foo.__cc)

obj = Foo("san")

obj.f3()

Foo.f3()


class Foo:

__cc = "123"


def __init__(self,name):

self.__name = name


def f1(self):

print(self.__name)


class Bar(Foo):

def f2(self):

print(self.__name)


# obj = Bar("san")

# obj.f2()

# obj.f1()

[/code]
强制访问私有，一般不可以使用print(obj._Foo__name)


五、特殊成员
__init__
构造方法，创建对象时自动执行
__del__
析构方法，当对象在内存中被释放时，自动触发执行
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
__doc__
表示类的描述信息
__module__
表示当前操作的对象在那个模块
__class__
表示当前操作的对象的类是什么
__call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __init__(self,name,age):

self.name = name

self.age = age


def __call__(self, *args, **kwargs):

print('call')


def __str__(self):

return '%s - %d' %(self.name,self.age)


obj = Foo()

obj()

[/code]
__dict__
获取对象中的所有字段数据

#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __init__(self,name,age):

self.name = name

self.age = age


def __call__(self, *args, **kwargs):

print('call')


def __str__(self):

return '%s - %d' %(self.name,self.age)


obj1 = Foo('san' , 18)

obj2 = Foo('yuli' , 19)


ret = obj1.__dict__

print(ret)

[/code]
__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __init__(self,name,age):

self.name = name

self.age = age


def __call__(self, *args, **kwargs):

print('call')


def __str__(self):

return '%s - %d' %(self.name,self.age)


obj1 = Foo('san' , 18)

obj2 = Foo('yuli' , 19)

print(obj1)

print(obj2)


ret = str(obj1)

print(ret)

[/code]
__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __init__(self,name,age):

self.name = name

self.age = age


def __call__(self, *args, **kwargs):

print('call')


def __str__(self):

return '%s - %d' %(self.name,self.age)


def __getitem__(self, item):

print('getitem')


def __setitem__(self, key, value):

print('setitem')


def __delitem__(self, key):

print('delitem')


obj = Foo('san' , 19)


ret  = obj['aa']# getitem

print(ret)


obj['k1'] = 111 # setitem


del obj['k1']   # delitem

[/code]

__getslice__、__setslice__、__delslice__
该三个方法用于分片操作注：该三个方法在Python3中已经弃用，Python3中直接使用__getitem__,__setitem__,__delitem__
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __init__(self,name,age):

self.name = name

self.age = age


def __call__(self, *args, **kwargs):

print('call')


def __str__(self):

return '%s - %d' %(self.name,self.age)


def __getitem__(self, item):

# item.startitem.stop   item.step

print(type(item))

return 123


def __setitem__(self, key, value):

# key.startkey.stop   key.step

print(type(key),type(value))


def __delitem__(self, key):

# key.startkey.stop   ikeytem.step

print(type(key))


obj = Foo('san' , 19)

ret = obj[1:4:2]

obj[1:4] = [11,22,33,44]

del obj[1:4]

[/code]
__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler


class Foo:


def __iter__(self):

return iter([11,22,33,44])


obj = Foo()

for item in obj:

print(item)

[/code]
__new__,__metaclass__





六、面向对象其他知识
- isinstance# 查看某个类是不是- issubclass# 查看某个类是不是子类


- 继承 2.7- 执行父类构造方法
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler

# 执行父类的构造方法


class C1:


def f1(self):

print('C1.f1')


class C2(C1):


def f1(self):

super(C2,self).f1() # 执行父类的f1

print('C2.f1')


obj = C2()

obj.f1()

[/code]
- 应用：
自定义类型，对字典进行补充，有序字典
#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler

# 有序字典


class MyDict(dict):


def __init__(self):

self.li = []

super(MyDict,self).__init__()


def __setitem__(self, key, value):

self.li.append(key)

super(MyDict,self).__setitem__(key,value)


def __str__(self):

temp_list = []

for key in self.li:

value = self.get(key)

temp_list.append("'%s',%s" %(key,value,))

temp_str = "{"+",".join(temp_list)+"}"

return temp_str


obj = MyDict()

obj['k1'] = 123

obj['k2'] = 456

print(obj)

[/code]
源码的扩展


七、异常处理



八、设计模式之单例模式（23种，goF设计模式）
单例模式
用来创建单个实例



#!/usr/bin/env python

# -.- coding: utf-8 -.-

# By sandler

# 单例模式


class Foo:

instance = None


def __init__(self,name):

self.name = name


@classmethod

def get_instance(cls):

# cls 类名

if cls.instance:

return cls.instance

else:

obj = cls("san")

cls.instance = obj

return obj


obj1 = Foo.get_instance()

print(obj1)

obj2 = Foo.get_instance()

print(obj2)

[/code]
类方法静态方法


来自为知笔记(Wiz)
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航