python 面向对象

python 面向对象

class Foo():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def skill(self):
        print(self.name ,self.age,"开大快跑")
obj=Foo("安妮",16)
obj.skill()
result:
安妮 16 开大快跑

self代表类的实例,而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()
以上实例执行结果为:
<__main__.Test instance at 0x10d066878>
__main__.Test
从执行结果可以很明显的看出,self 代表的是类的实例,代表当前对象的地址,而 self.class 则指向类。
self 不是 python 关键字,我们把他换成 runoob 也是可以正常执行的:

Python内置类属性

__dict__ : 类的属性(包含一个字典,由类的数据属性组成)
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块(类的全名是'__main__.className',如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)
__bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
Python内置类属性调用实例如下:
实例
class Person():
     city = "BeiJing" # 类的数据属性
     def __init__(self,name,age):
         self.Name = name
         self.Age = age
     def run(self):
          print('{} is running'.format(self.Name))
anni=Person("anni",16)
anni.run()
 print ("Person.__doc__:", Person.__doc__)
 print ("Person.__name__:", Person.__name__)
 print ("Person.__module__:", Person.__module__)
 print ("Person.__bases__:", Person.__bases__)
 print ("Person.__dict__:", Person.__dict__)
 result:
 Person.__doc__: None
 Person.__name__: Person
 Person.__module__: __main__
 Person.__bases__: (<class 'object'>,)
Person.__dict__: {'__module__': '__main__', 'city': 'BeiJing', '__init__': <function Person.__init__ at 0x00000000025EA8C8>, 'run': <function Person.run at 0x00000000025EA7B8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

类方法

class Person():
     city = "BeiJing" # 类的数据属性
     def __init__(self,name,age):
         self.Name = name
         self.Age = age
     def run(self):
          print('{} is running'.format(self.Name))
     @classmethod    //类方法
     def sleep(cls):     //cls替代self
         print(cls)
anni=Person("anni",16)
anni.run()
Person.sleep()
anni.sleep()
result:
anni is running
<class '__main__.Person'>
<class '__main__.Person'>

list、dict 等都成为工厂函数,它们本身就是一个类,谁调谁好使 谁调,就向谁的列表中添加

li = list('yangge')
print(type(li))
l2 = list('yangge')
l2.append(1)
li.append(2)
print(l2)
print(li)
result:
<class 'list'>
['y', 'a', 'n', 'g', 'g', 'e', 1]
['y', 'a', 'n', 'g', 'g', 'e', 2]

静态方法

class Math():
    @staticmethod
    def Add(a,b):
        print(a+b)
Math.Add(1,3)  #调用函数应该有2个参数就传2个参数
op=Math()
# 实例也可以使,但通常静态方法都是给类用的,实例在使时丧失了自动动传参的机制
op.Add(1,4)
result:
     4
     5
# 需求
# 1.定义三个类:Student Teacher ClassName
# 2.可以通过 Teacher的实例,可以查询到这个对象的所有学生,还可以查询到这个对象所管理的班级
# 3.学生必须创建4个,且至少分配给两个老师,还被分别分配到了两个班级
# a  c1 laowang
# b  c1 laowang
# c  c2 laoguo
# d  c2 laoguo
class Class():
    all_class=[]
    def __init__(self,name,teacher):
        self.name=name
        self.teacher=teacher
        Class.all_class.append(self)
class Student():
    all_stu=[]
    def __init__(self,name,teacher,class_name):
        self.teacher=teacher
        self.name=name
        self.class_name=class_name
        Student.all_stu.append(self)
class Teacher():
    def __init__(self,teacher):
        self.stu_list=[]
        self.class_list=[]
        self.teacher=teacher
    def echo_stu(self):
        for n in Student.all_stu:
            if(self.teacher == n.teacher):
                  self.stu_list.append(n.name)
        print(self.stu_list)
    def echo_class(self):
        for n in Class.all_class:
            if(self.teacher == n.teacher):
                  self.class_list.append(n.name)
        print(self.class_list)
a = Student('a','laowang','c1')
b = Student('b','laowang','c1')
c = Student('c','laoguo','c2')
d = Student('d','laoguo','c2')
c1= Class("c1","laowang")
c2= Class("c2","laoguo")

laowang = Teacher("laowang")
laowang.echo_stu()
laowang.echo_class()

laoguo = Teacher("laoguo")
laoguo.echo_stu()
laoguo.echo_class()

__mro__ c3算法

http://python.jobbole.com/85685/

继承 覆盖

class Vehicle:
    def __init__(self,name,brand,date):
        self.name=name
        self.brand=brand
        self.date=date
    def run(self):
        print( "the {} is running".format(self.name))
#对父类车进行继承
class car(Vehicle):
    def __init__(self,name,brand,date,speed):
        # self.name=name                        #法一 在子类中添加新的参数 调用父类初始化化的三种方法
        # self.brand=brand
        # self.date=date
        #Vehicle.__init__(self,name,brand,date) #法二
        super().__init__(name,brand,date)       #法三  python3的方法 且没有self
        self.speed=speed
    def run(self):  #覆盖父类的方法
        print("this {} is running speed {}".format(self.name,self.speed))
x6=car("宝马","x6","070101","200km/h")
x6.run()
print(x6.speed)

#多态

class Vehicle:
    def __init__(self,name,brand,date):
        self.name=name
        self.brand=brand
        self.date=date
    def run(self):
        print( "the {} is running".format(self.name))
#对父类车进行继承
class car(Vehicle):
    def __init__(self,name,brand,date,speed):
        super().__init__(name,brand,date)       #法三  python3的方法 且没有self
        self.speed=speed
    def run(self):  #覆盖父类的方法
        print("this {} is running speed {}".format(self.name,self.speed))
class bike(Vehicle):
    def __init__(self,name,brand,date,speed):
        super().__init__(name,brand,date)       #法三  python3的方法 且没有self
        self.speed=speed
    def run(self):  #覆盖父类的方法
        print("this {} is running speed {}".format(self.name,self.speed))

my_car=car("宝马","x6","070101","200km/h")
my_bike=bike("保时捷","x1","070101","20km/h")
def func(obj):       # 为了很好的展示多态性,还有再借个函数
    obj.run()
func(my_car)  
func(my_bike)

# @property, 指 getter 方法
# @name.setter, 指 setter 方法

class A():
    def __init__(self,name,age):
        self.__name=name    #添加___ 私有属性
        self.age=age
    @property
    def name(self):
        print("getter 被调用")
        return self.__name
    @name.setter
    def name(self,__name):
        print("settter 被设置了")
        self.__name=__name
a = A('shark',19)
a.age =10     #可以改写age
#a.name="zhu"  #不能改写 会报错
a.name="zhu"
print(a.name)
#print(a.name)
result:
settter 被设置了
getter 被调用
zhu

#反射(自省)
#模块是以.py结尾

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
obj=A('xiaoguo',17)
if hasattr(obj,'age'):
    getname=getattr(obj,'name')
    print(getname)
    setage=setattr(obj,'age',18)
    getage=getattr(obj,'age')
    print(getage)
print(A.__dict__)  #只有实例才有name属性
print(obj.__dict__)  #只有实例才有name属性
#result:
# xiaoguo
# 18
# {'__module__': '__main__', '__init__': <function A.__init__ at 0x00000000021FA840>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
# {'name': 'xiaoguo', 'age': 18}
import cls  #导入上一个例子模块 
a= getattr(cls,'A')  #通过反射得到A这个类
print(a)
obj1 = a("yang",29)
print(getattr(obj1,'name'))
print(isinstance(obj1,a))
# print(globals())

导入包里面的模块

# from pak import host,main  #法一 pak是个文件夹里面有host.py,main.py
import sys             #  模块搜索路径存储在 system 模块的 sys.path 变量中     
import pak.host                     #法二
import pak.main                    #法二
print(sys.path)
print(pak.host.host)
pak.main.connection("zz",80,"gg","root")

导入模块

from conf import settings     #可以将settins.py放到conf目录里
host_info={}
from importlib import import_module   #重点 以前没写出来卡住了
for key,value in settings.module_dic.items():
     # print(key,'   ',value)
     a,b = value.rsplit('.', 1)
     module_obj = import_module(a)    #***
     # print(module_obj)
     info=(getattr(module_obj,b)())
     host_info[key]=info
print(host_info)

魔术方法

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return "{}---{}".format(self.name,self.age) #要有返回值
obj1=Person("xiaoguo",19)
print(obj1)

抽象类 用于其他类继承他 被人继承他就得去实现他的方法

from abc import ABCMeta,abstractmethod
class chouxiang(metaclass=ABCMeta):
    @abstractmethod
    def get_info(self):
        pass
class a(chouxiang):
    def get_info(self):
        return "hello"
import abc
class chouxiang(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def foo(self):
        pass

paramiko 环境要装paramiko

import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
key_obj = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
ssh.connect('119.29.175.88',22,'root',pkey=key_obj)
stdin,stdout,stderr = ssh.exec_command('ip a')
res=str(stdout.read(),encoding='utf-8')

paramiko ssh

法1
#实例化SSHClient
    client = paramiko.SSHClient()
    #自动添加策略,保存服务器的主机名和密钥信息
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    #连接SSH服务端,以用户名和密码进行认证
    client.connect(ip,username=user,password=passwd)
    #打开一个Channel并执行命令
    stdin,stdout,stderr = client.exec_command(command)
    #打印执行结果
    print stdout.readlines()
    #关闭SSHClient
    client.close()
法2
#实例化SSHClient
client = paramiko.SSHClient()
#自动添加策略,保存服务器的主机名和密钥信息
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#连接SSH服务端,以用户名和密码进行认证
client.connect(ip,username=user,password=passwd)
#实例化Transport,并建立会话Session
ssh_session = client.get_transport().open_session()
if ssh_session.active:
    ssh_session.exec_command(command)
    print ssh_session.recv(1024)
client.close()

迭代器

TIM截图20180723113737.png

有限序列变无限序列
from itertools import cycle
counter2 = cycle(['a','b','c'])
for i in range(1,10):
    print(counter2.__next__())
无限序列
from itertools import count
counter = count(start=2)
print(hasattr(counter,'__next__'))
print(hasattr(counter,'__iter__'))
for i in range(1,10):
    print(counter.__next__())

获取迭代器

def foo():
    for i in range(5):
        yield i
g_obj = foo()
#shengchengqi hanshu
print(hasattr(g_obj,'__iter__'))
print(hasattr(g_obj,'__next__'))
print(next(g_obj))
li_obj = (i for i in range(100000)) #用()产生对象 里面有算法
print(li_obj)
#list(range(100000)) 延迟算法
def iter1():
    for i in range(10):
        yield i
g =iter1()
g1=(i for i in g)
print(list(g1))
g2=(i for i in g1)
print(list(g2))
result:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]

推荐阅读更多精彩内容

  • Python 面向对象Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对...
    顺毛阅读 3,273评论 4 16
  • Python 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个...
    今早上阅读 147评论 0 0
  • 一、面向对象,这个对象到底是什么? 这个对象不是python中的实例,python中我们把一个类的实例也叫做对象,...
    youngkun阅读 474评论 0 2
  • Python面向对象编程 面向对象的编程产生的历史原因:由于面向过程编程在构造系统时,无法解决重用,维护,扩展的问...
    学成秃子我不怕阅读 266评论 1 2
  • 人最难做的是始终如一,而最易做的是变幻无常,让我们在从容中感受生命的美好! 2017.9.15 星期五 晴转雨 人...
    Ocean蔚蓝的海阅读 252评论 11 10