面向对象进阶博客地址链接：

http://www.cnblogs.com/Eva-J/articles/7351812.html　　

复习昨日内容：

# 包

# 开发规范

    #

# hashlib

    # 登录验证 密文密码检测

        # 密文存储

        # 加盐

        # 动态加盐

    # 检测文件一致性   md5

        #MD5.update()

# configparser ： 配置文件相关

    #网络编程 ftp

    #[section1]

    #o1 = yes

# logging : 日志

    #记录一些信息和结果

    #打日志

    #日志就和print

    #学生管理系统

        #需要用户选择的时候打印的提示信息

        #一个程序和用户发生文字交互的时候，不能使用logging

    # 中间结果 错误提示 都可以使用logging

    # 管理员在某时某刻创建了一个班级 —— logging

今日概要：

# 欠你得内置函数  ***

# 反射 *****

# 类的内置双下方法 ***

# 面向对象的高级代码和一道面试题

    # 看书

    # 看源码

    # 看博客

        #简书

        #csdn

内置函数：

#property

#classmethod

#staticmethod

#super

#object

#isinstance

#issubclass

#vars

# from collections import Iterable

# print(isinstance([],Iterable))

# class A:pass

# class B(A):pass

# b = B()

# print(isinstance(b,A))

# print(isinstance(a,object))

# class A:pass

# class B(A):pass

# print(issubclass(B,A))

# print(issubclass(A,B))

# print(issubclass(A,object))

# print(issubclass(B,object))

#isinstance(对象，类) 判断这个对象是不是这个类或者这个类的子类的实例化

#看全局

# a = 1

# b = 2

# print(vars())

# print(dir())

class A:

    '''

    描述管理员的类

    '''

    c = 1

    d = 2

    def func(self,name):

        '''

        这个函数整体是做什么的

        :param name: 管理员的姓名

        :return: 管理员的信息

        '''

        self.name = 'alex'

#看类

# print(vars(A))

a = A()

a.func()

#看对象

print(vars(a))

'''

       这个函数的主要功能

       :return:

       '''

反射：这个很重要，必须要学会！

# hasattr()

# getattr()

# setattr()

# delattr()

# a = 1

# name = 'a'

# print(vars())

# print(vars()[name])

# eval()

class Management:

    role = '管理员'

    def __init__(self,name,sex,phone,mail):

        self.name = name

        self.sex = sex

        self.phone = phone

        self.mail = mail

    def creat_class(self):

        print('创建了一个班级')

    def creat_teacher(self):

        print('新建了一条讲师信息')

    def creat_student(self):

        print('新建了一条学生信息')

# Management.role

# if hasattr(Management,'role'):

#     print(getattr(Management,'role'))

# import logging

# manager = Management('小雨','女',1233211234567,'xiaoyu@qq.com')

# if hasattr(manager,'sex1'):

#     sex = getattr(manager,'sex1')  #使用字符串数据类型的变量名获取属性值

#     print(sex)

# else:

#     logging.warning('没有您输入的属性')

# cs = getattr(manager,'creat_class') #使用字符串数据类型的方法名调用方法

# cs()

# Management.Country = 'China'

# setattr(Management,'Country','China')

# print(Management.Country)

# del Management.Country

# delattr(Management,'Country')

# print(Management.Country)

# manager = Management('小雨','女',1233211234567,'xiaoyu@qq.com')

# manager.hobby = '点名'

# setattr(manager,'hobby','点名')

# print(manager.hobby)

#可以通过delattr删除一个类中的方法

# delattr(Management,'creat_class')

# manager.creat_class()

# def create_course(self):

#     print('创建了一个课程')

# setattr(manager,'create_course',create_course)

# manager.create_course(manager)

# hasattr(对象名，'属性名')  返回True或False

#属性值 = getattr(对象名，'属性名')

#方法的内存地址 = getattr(对象名，'方法名')

#方法的内存地址()

# import demo

# # demo.a

# print(getattr(demo,'a'))

# qq = getattr(demo,'qqxing')

# ret = qq('wahaha')

# print(ret)

# aaa = 'bbb'

# import sys

# print(sys.modules[__name__])

# print(getattr(sys.modules[__name__],'aaa'))

# 对象的反射

# 类的反射

# 模块的反射

# 本模块的反射 : 找到本模块sys.modules[__name__]

反射包括在类中对象的反射，类的反射，以及模块的反射，还有程序所处当前位置的本模块的反射。

类的内置方法：

#str 和 repr

# class A:

#     # pass

#     def __str__(self):

#         return 'A的对象'

    # def __repr__(self):

    #     return 'repr: A的对象'

# a = A()

# print(a)  #本质调用的是__str__，如果没实现，就调用__repr__, 再找不到，用object父类的

# print(a.__str__())  #str却不能给repr做备胎

# print(a.__repr__()) #repr是str的备胎

# 打印一个对象的时候，实际上是调用了这个对象所在类的__str__方法，打印的是这个方法的返回值

# print(str(a))

# print(repr(a))

# print('%s'%a)

# print('%r'%a)

# print(a)

# l = list()

# print(l)

# format_dict={

#     'nat':'{o.name}-{o.addr}-{o.type}',#学校名-学校地址-学校类型

#     'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址

#     'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名

# }

# class School:

#     def __init__(self,name,addr,type):

#         self.name=name

#         self.addr=addr

#         self.type=type

#

#     def __format__(self, format_spec): #format_spec = 'nat'

#         fmt='''=====================

# 姓名 ： {obj.name}

# 班级 ： {obj.addr}

# ====================='''

#         return fmt.format(obj=self)

# s1=School('oldboy1','北京','私立')

# print(format(s1,'nat'))

# print(format(s1,'tna'))

# print(format(s1,'tan'))

# print(format(s1,'asfdasdffd'))

#打印学生信息

#姓名 班级 性别 年龄

#=====================

# 姓名 ： name

# 班级 ： class

#=====================

# 析构方法

# 周期 ：0

# 12  一个亿个对象 del 对象

# class A:

#     def __del__(self):

#         '''

#         析构方法

#         这个方法只有在执行del A类的对象的时候才被触发

#         且先执行代码中的内容，再删除对象

#         如果我删除了这个对象，它跟着还有一些其他的附属的内容也没有用了

#         我们就可以在这个方法中回收掉

#         '''

#         print('执行我啦！')

#         self.b.close()

# f = open('file','w')

# a = A()

# a.b = f

# del a

# print(a)

class Foo:

    def __init__(self,name):

        self.name=name

    def __getitem__(self, item):

        if item == 1:

            print('hahaha')

        # print(self.__dict__[item])

    def __setitem__(self, key, value):

        self.__dict__[key]=value

    def __delitem__(self, key):

        print('del obj[key]时,我执行')

        self.__dict__.pop(key)

    def __delattr__(self, item):

        print('del obj.key时,我执行')

        self.__dict__.pop(item)

f1 = Foo('sb')

#访问属性的方式变了

#对象名.属性

# f1=Foo('sb')

# f1['age']=18  #给f1添加一个属性

# del f1['age']  #删除属性

# # f1.name

# print(f1['name'])

#

# f1.__dict__['age'] = 18

# f1['age1']=19

# del f1.age1   #删除属性

#

# f1['name']='alex'

# print(f1.__dict__)

#pytho内部的约定

#关于item ： 对象访问 如果是 对象名[]，是因为内部实现了item系列的方法

# 对象的实例化

    #创造一个裸地对象 —— __new__  ****

    #初始化

# 单例模式 —— 设计模式

# 一个类 从头到尾 只创建 一个对象

# class Singleton:

#     def __new__(cls, *args):

#         if not hasattr(cls, '_instance'):

#             cls._instance = object.__new__(cls)

#         return cls._instance

#

#     def __init__(self,name):

#         self.name = name

#

# one = Singleton('alex')

# print(one.name)

# two = one

# two.name = 'egon'

# # two = Singleton('egon')

# # print(two.name)

# # print(one.name)

# print(id(one),id(two))

# class Foo:

#     def __init__(self):

#         pass

#

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

#         print('__call__')

#

# Foo()()   #对象名()

# class A:

#     def __eq__(self,obj):   #equal : 相等

#         # if  self.a == obj.a and self.b == obj.b:

#             return True

# a = A()

# b = A()

# a.name = 'alex'

# b.name = 'egon'

# print(a == b)

# from collections import namedtuple

# Card = namedtuple('Card',['rank','suit'])

# class FranchDeck:

#     ranks = [str(n) for n in range(2,11)] + list('JQKA')

#     suits = ['红心','方板','梅花','黑桃']

#     def __init__(self):

#         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks

#                                         for suit in FranchDeck.suits]

#

#     def __len__(self):

#         return len(self._cards)

#

#     def __getitem__(self, item):

#         return self._cards[item]

#

#     def __setitem__(self, key, value):

#         self._cards[key] = value

#

# deck = FranchDeck()

# # print(deck._cards)

# print(deck[0])

# # from random import choice

# # print(choice(deck))

# # print(choice(deck))

# from random import shuffle

# shuffle(deck)

# print(deck._cards)

# 一个类 有 100个 对象，每一个对象都拥有三个属性：name，sex，age

# 如果两个对象的name和sex属性完全一致

# 我就认为这是一个对象

# 请对这100个对象进行去重

# class Person:

#     def __init__(self,name,age,sex):

#         self.name = name

#         self.age = age

#         self.sex = sex

#     def __hash__(self):

#         return hash(self.name+self.sex)

#     def __eq__(self, other):

#         if self.name == other.name and self.sex == other.sex:return True

#

# p_lst = []

# for i in range(84):

#     p_lst.append(Person('egon',i,'male'))

# print(set(p_lst))

下面这一版的内置方法是添加了更多的更详尽注释的：

# str 和 repr

# class A:

#     # pass

#     def __str__(self):

#         return 'A的对象'

    # def __repr__(self):

    #     return 'repr: A的对象'

# a = A()

# print(a)  # 本质调用的是__str__，如果没实现，就调用__repr__, 再找不到，用object父类的

# print(a.__str__())  # str却不能给repr做备胎

# print(a.__repr__()) # repr是str的备胎

# 打印一个对象的时候，实际上是调用了这个对象所在类的__str__方法，打印的是这个方法的返回值

# print(str(a))

# print(repr(a))

# print('%s'%a)

# print('%r'%a)

# print(a)

# l = list()

# print(l)

# format_dict={

#     'nat':'{o.name}-{o.addr}-{o.type}',#学校名-学校地址-学校类型

#     'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址

#     'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名

# }

# class School:

#     def __init__(self,name,addr,type):

#         self.name=name

#         self.addr=addr

#         self.type=type

#

#     def __format__(self, format_spec): #format_spec = 'nat'

#         fmt='''=====================

# 姓名 ： {obj.name}

# 班级 ： {obj.addr}

# ====================='''

#         return fmt.format(obj=self)

# s1=School('oldboy1','北京','私立')

# print(format(s1,'nat'))

# print(format(s1,'tna'))

# print(format(s1,'tan'))

# print(format(s1,'asfdasdffd'))

# 打印学生信息

# 姓名 班级 性别 年龄

# =====================

# 姓名 ： name

# 班级 ： class

# =====================

# 析构方法

# 周期 ：0

# 12  一个亿的对象 del 对象

# class A:

#     def __del__(self):

#         '''

#         析构方法

#         这个方法只有在执行del A类的对象的时候才被触发

#         且先执行代码中的内容，再删除对象

#         如果我删除了这个对象，它跟着还有一些其他的附属的内容也没有用了

#         我们就可以在这个方法中回收掉

#         '''

#         print('执行我啦！')

#         self.b.close()  ## 这里self就是a，self是实例化的对象，所以a.b就是self.b

#  所以这里也解释了为什么这里的b要和下面a后面的b保持一致的原因

# f = open('file','w')

# a = A()

# a.b = f  ## 这里是添加一个属性,a是A实例化出来的一个对象，a.b = f 这是把对象所添加的属性赋值给f

# del a

# print(a)

class Foo:

    def __init__(self,name):

        self.name=name

    def __getitem__(self, item):

        if item == 1:

            print('hahaha')

        # print(self.__dict__[item])

    def __setitem__(self, key, value):

        self.__dict__[key] = value

    def __delitem__(self, key):

        print('del obj[key]时,我执行')

        self.__dict__.pop(key)

    def __delattr__(self, item):

        print('del obj.key时,我执行')

        self.__dict__.pop(item)

f1 = Foo('sb')

# 访问属性的方式变了

# 对象名.属性

# f1=Foo('sb')

# f1['age']=18  #给f1添加一个属性

# del f1['age']  #删除属性

# # f1.name

# print(f1['name'])

#

# f1.__dict__['age'] = 18

# f1['age1']=19

# del f1.age1   #删除属性

#

# f1['name']='alex'

# print(f1.__dict__)

#pytho内部的约定

#关于item ： 对象访问 如果是 对象名[]，是因为内部实现了item系列的方法

# 对象的实例化

    # 创造一个裸地对象 —— __new__  ****

    # 初始化

# 单例模式 —— 设计模式

# 一个类 从头到尾 只创建 一个对象

# class Singleton:

#     def __new__(cls, *args):

#         if not hasattr(cls, '_instance'):

#             cls._instance = object.__new__(cls)

#         return cls._instance

#

#     def __init__(self,name):

#         self.name = name

#

# one = Singleton('alex')

# print(one.name)

# two = one

# two.name = 'egon'

# # two = Singleton('egon')

# # print(two.name)

# # print(one.name)

# print(id(one),id(two))

# class Foo:

#     def __init__(self):

#         pass

#

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

#         print('__call__')

#

# Foo()()   #对象名()

# class A:

#     def __eq__(self,obj):   #equal : 相等

#         # if  self.a == obj.a and self.b == obj.b:

#             return True

# a = A()

# b = A()

# a.name = 'alex'

# b.name = 'egon'

# print(a == b)

# from collections import namedtuple

# Card = namedtuple('Card',['rank','suit'])

# class FranchDeck:

#     ranks = [str(n) for n in range(2,11)] + list('JQKA')

#     suits = ['红心','方板','梅花','黑桃']

#     def __init__(self):

#         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks

#                                         for suit in FranchDeck.suits]

#

#     def __len__(self):

#         return len(self._cards)

#

#     def __getitem__(self, item):

#         return self._cards[item]

#

#     def __setitem__(self, key, value):

#         self._cards[key] = value

#

# deck = FranchDeck()

# print(deck._cards)

# print(deck[0])

# # from random import choice

# # print(choice(deck))

# # print(choice(deck))

# from random import shuffle

# shuffle(deck)

# print(deck._cards)

# 一个类 有 100个 对象，每一个对象都拥有三个属性：name，sex，age

# 如果两个对象的name和sex属性完全一致

# 我就认为这是一个对象

# 请对这100个对象进行去重

class Person:

    def __init__(self,name,age,sex):

        self.name = name

        self.age = age

        self.sex = sex

    def __hash__(self):  # 这里使用hash方法把字符串拼接起来，得到一个新的字符串，

        # 如果得到的新的字符串都相同那么这两个元素就是想等的，不仅仅是字符串可以用hash，hash是不可变的数据类型，

        # （可hash不可变数据类型）

        return hash(self.name+self.sex)

    def __eq__(self, other):  # 我们去重需要使用集合，因为集合的最大特点就是去重，那么集合里面不仅仅是包含了不可变

        # 数据类型，还有可变数据类型，当我们遇到可变数据类型的时候那么我们就需要使用eq去判断他们的值是否相等了，

        # 这样使得程序更加趋于完善，可以hold住更多的可能

        if self.name == other.name and self.sex == other.sex:return True

p_lst = []

for i in range(84):

    p_lst.append(Person('egon', i, 'male'))

print(set(p_lst))

# 一句话总结就是可hash属于不可变的数据类型，需要使用hash去判断是否相等，

# 那么不可hash可变的数据类型呢，就不能够使用hash去判断了，需要使用eq去判断是否相等

day28 面向对象：反射，内置函数，类的内置方法的更多相关文章

  1. python面向对象的多态-类相关内置函数-类内置魔法函数-迭代器协议-上下文管理-04

    多态 一种事物具备不同的形态 例如:水 --> 固态.液态.气态 多态:# 多个不同对象可以相应同一个对象,产生不同的结果 首先强调,多态不是一种特殊的语法,而是一种状态,特性(多个不同对象可以 ...

  2. 面向对象进阶------>内置函数 str repr new call 方法

    __new__方法: 我们来讲个非常非常重要的内置函数和init一样重要__new__其实在实例话对象的开始  是先继承父类中的new方法再执行init的  就好比你生孩子 先要把孩子生出来才能对孩子 ...

  3. daｙ　28 hasattr getattr serattr delattr 和带__内置__ 类的内置方法

    反射 后边有关字符串的# class Management:# role = '管理员'# def __init__(self,name,sex,phone,mail):# self.name = n ...

  4. mysql 内置函数大全 mysql内置函数大全

    mysql 内置函数大全 2013年01月15日 19:02:03 阅读数:4698 对于针对字符串位置的操作,第一个位置被标记为1. ASCII(str) 返回字符串str的最左面字符的ASCII代 ...

  5. CG 内置函数 和 HLSL 内置函数

    CG 内置函数  英伟达官网链接: http://http.developer.nvidia.com/Cg/index_stdlib.html absacosallanyasinatan2atanbi ...

  6. python中的 dir()内置函数的作用以及使用方法

    dir() 内置函数的作用 python 内置方法有很多,无论是初学者还是精通python 的程序员都不能全部即住所有的方法,这时候 dir() 方法就非常有用了,使用 dir()函数可以查看对象内的 ...

  7. 【Android开发经验】使用反射，得到的类的字段、方法、并实现了简单的调用

    本文后推出Android的ICO框架做准备,所以,假设你想要一个最近的一项研究Android的ICO学生框架.你可以稍微看一下. 首先,简介一下Java里面的反射. JAVA反射机制是在执行状态中,对 ...

  8. 浅谈Java反射机制 之 使用类的 属性、方法和构造函数

    前面两篇我们总结了Java反射机制如何获取类的字节码,如何获取构造函数,属性和方法, 这篇我们将进一步验证如何使用我们获取到的属性.方法以及构造函数 1.使用 反射 获取到的 属性 import ja ...

  9. js内置函数大全及基本使用方法（一）

    一,常规函数 alert函数:显示一个警告对话框,包括一个OK按钮. 语法:alert("hello world"); confirm函数:显示一个确认对话框,包括OK.Cance ...

  10. Python3基础 内置函数 dir 查询对象的方法列表

             Python : 3.7.3          OS : Ubuntu 18.04.2 LTS         IDE : pycharm-community-2019.1.3    ...

随机推荐

  1. 2018年Android的保活方案效果统计

    一.常见保活方案 1.监听广播:监听全局的静态广播,比如时间更新的广播.开机广播.解锁屏.网络状态.解锁加锁亮屏暗屏(3.1版本),高版本需要应用开机后运行一次才能监听这些系统广播,目前此方案失效.可 ...

  2. swift 学习- 10 -- 类和结构体

    // '类和结构体' 是人们构建代码所使用的一种通用且灵活的构造体, 我们可以使用完全相同的语法规则来为 '类和结构体' 定义属性 (变量 和 常量) 和添加方法, 从而扩展 类和结构体 的功能 // ...

  3. iOS UIDatePicker设置为中文的方法

    UIDatePicker *datePicker = [[UIDatePicker alloc] initWithFrame:CGRectMake(0, 20, 200, 30)]; datePick ...

  4. Confluence 6 从关闭的连接中恢复

    当数据库服务器进行重启或者因为网络问题导致连接中断.所有在数据库连接池中的连接都会被中断.希望处理这个问题,通常需要 Confluence 进行重启. 但是,数据库连接池中的连接可以通过运行 SQL ...

  5. npm常用模块

    https://blog.csdn.net/heliumlau/article/details/70577727

  6. kali 局域网嗅探

    1.局域网图片嗅探 工具  arpspoof arpspoof -i eth0 -t 192.1681.10(网卡 目标地址) 192.168.1.1 局域网网关,如果在Windows中可以使用局域网 ...

  7. Unity3D料槽设备旋转（一）

    1.使用C#创建控制游戏对象的的脚本语言, 第一步: 在project师徒中create 一个C#脚本,将其按照自己的设备名称进行命名,这里我将其简单的命名成zhuaquanzhou.cs 使用编辑器 ...

  8. LabView(控件部分)

    1.虚拟仪器的概述: 虚拟仪器是基于计算机的的仪器,计算机和仪器的密切结合是目前仪器的一个发展方向,大概有两种结合方式,一种是将计算机装入仪器中,实例就是只能化的仪器,流行的嵌入式系统的仪器,另一种就 ...

  9. bzoj 2186

    非常有趣的题 题意:求1~N!中有多少个与M!互质的数,T组询问,答案对R取模 题解: 首先,因为N>M,所以N!>M!,所以答案一定有一部分是φ(M!) 接下来做一些分析: 引理: 若x ...

  10. js中onload和jQuery中的ready区别

    window.onload必须等到页面内包括图片的所有元素加载完毕后才能执行. ------>不能写多个(如果有多个,只会执行一个) $(document).ready()是DOM结构绘制完毕后 ...