面向对象进阶

8.7

访问可见性问题：

  1 、私有变量

     ## 私有变量,变量名前面加"__" ##
     ## 私有变量/函数,在类内部可以直接调用，不可在外部调用；##
     ## 如果你想体现一个变量/函数特别重要你可以使用"_"##

例：

 

例：编辑三个数（私有），求出它们的和，并更改其中的两个数

 2、__slots__魔法

注意的是__slots__的限定只对当前类的对象生效，对继承的子类并不起任何作用。

例：

 在python中类是动态的

8.8   

 静态方法和类方法

 1、静态

"""
如果类中需要非该类成员存在,则可以使用静态调用的方法@staticmethod
"""

案例： 输入四条边判断它是否是一个正方形；如果是计算面积；@staticmethod

class skittles(object):
    def __init__(self,a,b,c,d):
        self.a=a
        self.b=b
        self.c=c
        self.d=d
    @staticmethod
    def is_valid(a,b,c,d):
        for i in [b,c,d]:
            
            if i !=a:
                return Flase
        else:
            return True
    def area(self):
        if res == True:
            area_ = self.a * self.c
            return area_
aaa=skittles(4,4,4,4)
res=aaa.is_valid(4,4,4,4)
if res == True:
     print(aaa.area())
  输出：16         

 

2、类方法 

  

    2.1  默认值

‘’‘’‘’‘’

 

 def  A(jianying = 'lele'):
       print(jianying)                            ##不赋值时，返回默认值##
  A( )
  输出 → lele

 

‘’‘’‘’‘’‘

     2.2 时间戳

’‘’‘’‘’‘’

 

  from  time  import  time , localtime , sleep        

    print (  localtime (time) ) )                 ##时间戳，从1970年1月1日00.00.00秒开始到现在已经经历过的秒数#

 

#

’‘’‘’‘’‘’

     2.3 类的调用

’‘’‘’‘’‘’
@classmethod:获取自身类(cls)中的属性,并且可以更改.
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

‘’‘’‘’‘’‘‘

 

class A(object):
    def __init__(self):
        self.xiaocui = 100
    @classmethod
    def a(cls):
        return cls()   ## cls绑定自身的类
c = A.a()
print (c.xiaocui)
输出：100

 

3、类与类之间的关系

    ##私有变量、函数不可被继承##

      3.1 继承

 

 例：（ 不带参数）

创建一个父类，创建一个子类；父类计算两个数字的和记为SUM_；子类打印这个SUM_;

‘’‘’‘’‘’‘’

class father(object):      ## 父类
    def __init__(self):
        self.a=100
        self.b=200
    def sum(self): 
        SUM_=self.a+self.b
        return SUM_
class son(father):        ## 子类 ； 在类名中写继承的类
    def __init__(self):        ## 子类
        father.__init__(self)   ## 父类
    def Son(self):
        res=self.sum()
        print(res)
family=son()
family.Son()
输出：300

’‘’‘’‘’‘’‘’

案例：（带参）

‘’‘’‘’‘’‘’‘

class A(object):
    def __init__(self,a):
        self.joker_1=100
    def A1(self):
        print('A1')
class B(A):
    def __init__(self,a,b):
        A.__init__(self,a)
aaa = B(1,2)
print(aaa.joker_1)
输出：100

’‘’‘’‘’‘’‘’‘

   列表生成式

 优点: 计算速度快,因为一次性已经全部加载到内存中了,适合数据量不是太大的情况10000- 2000-

缺点: 占用内存

案例1：

 ''''''''''''

  A = [ x  for  x   in   range(100) ]

           print ( A ) 
  输出：[ 0,1,2,...,99 ]

'''''''''''''

案例2：

'''''''''''''

 a = [ x  for  x   in   range(100) if  x%2  == 0 ]

        print ( a )
 输出：[ 0,2,4,...,98 ]

'''''''''''''

 列表生成器

优点: 节约内存空间
缺点: 计算速度慢,因为要生成.

’‘’‘’‘’‘’‘’  

  a = (x for x in range(100000000000) if x % 2== 0)

         print（ next （ a ））
  输出：0

 ’‘’‘’‘’‘’‘’

 列表装饰器

 案例1：创建一个装饰器，一个函数（两个参数）；用装饰器处理两个参数的和，并打印

def deco(func):
    def A(a1,a2):
        res=a1+a2
        print(a1,a2,res)
        return func(a1,a2)
    return A
@deco
def jy(i,o):
    print()
jy(1,2)
输出：1  2  3

案例2：

def jxh(func):
    def warp(n1,n2,n3):
        num = n1 + n2 
        return func(0,num,n3)
    return warp
#装饰器将前两个数字求和,函数本身第三个参数乘上这个和
@jxh
def SUM(num1,num2,num3):
    print(num1,num2,num3)
    print(num2 * num3)
SUM(10,2,3)
输出：0  12  3
     36

补充：

  1、函数闭包：

def foo():
     def  bar():
          return ' hello '
     return bar()
f1 = foo()     ##f1是函数
print ( f1 )
 输出：hello

  2、（编辑器）vim 创建：vim  touch jy.md ;

                                进入：vim  jy.md

                                复制：ctrl + shift +c