Python语言学习

面向对象

静态函数，类函数，成员函数，属性函数的区别

补充知识：

• 实例变量：每个实例独有的变量

• 类变量：所有实例共享的变量

  形象理解：哈士奇（类变量）是狗的一种，而每只狗都只会有一个主人给它取唯一的名字，例如“蛤蛤”（成员变量）。用代码来解释就是

  class Dog:
      kind = "Husky" # 类变量
      def __init__(self, name):
          self.name = name # 实例变量

  四类函数的定义

  明确了实例变量和类变量之后，四类函数就很好理解了。先看官方定义：

• 静态函数（@staticmethod）:即静态方法,不可以访问实例变量或类变量。

• 类函数（@classmethod）：只能访问类变量，不能访问实例变量。
• 成员函数：实例后使用的方法，且只能通过实例进行调用。
• 属性函数（@property）：通过装饰器@property把一个方法变成一个静态属性

四类函数的形象解释

再次请出“蛤蛤”，首先讲解静态函数:通俗的说静态方法就是函数的形参中没有self。也即，静态函数与类中的静态变量&实例变量都没有半毛钱关系

class Dog(object):

    @staticmethod
    def bark():
        print("my name is Haha")

d1 = Dog()
d1.bark()
# 使用静态方法，输出结果为my name is Haha

那么类函数呢？

class Dog(object):
    name = "Haha"
    
    @classmethod
    def bark(cls):
        print("my name is %s" % cls.name)

d2 = Dog()
d2.bark()
# 使用类方法，输出结果为my name is Haha

再看看成员函数

class Dog(object):
    name = "Haha"
    
    def __init__(self, nick_name):
        self.nick_name = nick_name
    def bark(self):
        print("my name is %s and my nick name is %s" % (name,self.nick_name))
d3 = Dog("Heiha")
d3.bark()
# 使用成员函数，输出结果为my name is Haha and my nick name is Heiha
```    
最后看看属性函数：
```py
class Dog(obkect):
    def __init__(self, name):
        self.name = name
    @property
    def bark(self):
        print("my name is %s" % self.name)
# 使用属性函数的方式需要注意！此时bark函数已经是Dog类的一个属性。
d4 = Dog("Haha")
# 如此使用属性函数，输出结果为myname is Haha
d4.talk

补充：@property的使用

为什么需要有@property装饰器？

编程中出现的问题：绑定属性的时候无法检查参数！

• 解决方案一：在类中定义set()和get()方法来设置与获取成绩。这么写是OK的，但是当你把类进行实例化之后，就会懂得这个方案的麻烦程度了。

@property把方法变成属性调用

　使用方法：把你想要设置的属性变成一个getter方法，在加上@property装饰器，在setter方法里就可以检查参数的合法性了。
　实例化之后，就可以直接绑定属性而不用再去调用类方法！

class Student(object):
    @property
    def score(self):
        return self._score
    
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('scofre must between 0-100!')
        self._score = value

# 实例化
s = Student()
s.score = 60 # equal to s.set_score(60)
s.score = 101 
# Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

四类函数的小总结：

综上所述，其实我们可以四类函数当做一个逐渐释放权力的过程。当使用静态函数时，类的任何信息你都无权得到；当你使用类函数时，你只可以得到类变量里面的信息，而无法得到实例化之后的类的信息；只有当你使用成员函数，你的权力才得到完整的释放，你既可以使用类变量的信息又可以使用实例化后类的信息。而属性函数则是把一个函数当做属性来看待，这是最好理解的。

我还是不懂何时使用它们怎么办？

记住核心思想：

1. 类函数主要用途是作为构造函数。
2. 静态函数的形参没有self
3. 成员函数用的最多

类的访问控制：单下划线_与双下划线__

1. “_”:单下划线表示只允许其本身与其子类进行访问
2. “__”:双下划线表示只允许这个类本身进行访问。

python语言特性

python是动态类型语言

在编写代码的时候可以不指定变量的数据类型

with语句：

# 1. with语句的语法格式
with content_expression [as targer(s)]:
    with-body
# 2. with语句操作文件对象
with open(r'somefileName') as somefile:
    for line in somefile:
        print line
        # ... more code
# 3. 上文代码等价于下文代码：
somefile = open(r'openfileName')
try:
    for line in somefile:
        print line
        # ...more code
finally:
    somefile.close()

错误处理

1. 一个简单易懂的例子:如果某些代码可能会出错

   try:
       r = 10 / 0
   except ZeroDivisonError, e:
       print "ZeroDivisionError", e
   except ValueError, e:
       print "ValueError", e
   finally:
       print 'finally'

2. 记录错误：打印错误信息，同时让程序继续执行

   import logging
   def foo(s):
       return 10 / int(s)
   def main():
       try:
           foo('0')
       except StandardError, e:
           logging.exception(e)
   main()
   print "END"

   　程序打印完错误信息后会继续执行，并且正常退出。

3. 抛出错误

   try:
       10 / 0
   except ZeroDivisionError:
       raise ValueError('input error!')

代码trick

再见！中间变量

a = 1
b = 2
#不使用中间变量交换两个变量的值
a, b = b, a

字符串逆序

实质是把字符串转换成列表进行操作

a = "python"
# 方法一:看起来很装逼的方法
print a[::-1] # "nohtyp" 
# 方法二：可读性强的方法
print list(a).reverse()

python可以使用连续赋值, 从左至右

x = [0, 1]
i = 0
# 当我们连续赋值的时候
i, x[i] = 1, 2
# print(x)的结果为[0, 2]:编译器先把1赋值给了i，那么x[i]即为x[1]，接下来把2赋值给了x[1]。

矩阵转置

其原理为zip()函数：将对象中对应的元素打包成一个个元组，并且返回由元组组成的列表。这恰好符合矩阵转置的操作

mat = [[1, 2, 3], [4, 5, 6]]
# *可以简单理解为解压
print zip(*mat)
#[(1, 4), (2, 5), (3, 6)]

列表转字符串

a = ["Code", "mentor", "Python", "Developer"]
print " ".join(a)
# Code mentor Python Developer

在一个for循环中遍历两个列表

list1 = ['a','b','c','d']
list2 = ['apple','boy','cat','dog']
for x,y in zip(list1, list2):
    print x 'is' y

同时处理多个文件

with open(filename1) as fp1, open(filename2) as fp2, open(filename3) as fp3:
for l1 in fp1:
    l2 = fp2.readline()
    l3 = fp3.readline()
    # do something

给字符串前面补“0”

num = "123"
# 向num前面填充0至总位数为5
str_n = num.zfill(5)

回调函数 callback()

官方解释：

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

形象解释：

吃饭、喝水、睡觉就是一个通过大脑调用的动作。如果你把这些动作作为参数传递给大脑，当这些动作被用来真正去执行时，我们就说这是回调函数。

代码解释：

def eat(food):
    print "I will eat ", food
def drink(beverage):
    print "I will drink ", beverage

def brain(action, target):
    return action(target)
```     


# __all__与__metaclass__的使用
## __all__
**第一时间**展现了模块的内容大纲，更**清晰**地提供了外部访问的接口。但是要注意，只有列表里内内容才会暴露出去！

请看代码：
### 测试文件foo.py
```py
__all__ = ['pig', 'monkey', 'deer']

deer = 10086
monkey = 10010
def pig():
    return "awesome"

测试文件

from foo import *
print(bar)
print(monkey)
print(deer) 

参考与引用

1. https://m.baidu.com/?from=844b&vit=fps&nsukey=QL%2FYJKapoliD84rv4ROf08qlZJ83uWDoXzrVj
2. https://www.cnblogs.com/scf141592/p/5726347.html
3. https://www.cnblogs.com/crazyrunning/p/6945183.html
4. https://www.cnblogs.com/polly333/p/8143672.html
5. https://www.cnblogs.com/crazyrunning/p/6945183.html
6. https://www.cnblogs.com/imageSet/p/7473326.html
7. https://www.jianshu.com/p/4bd8a1c93cbe
8. https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820062641f3bcc60a4b164f8d91df476445697b9e000
9. https://www.liaoxuefeng.com/
10. https://www.ibm.com/developerworks/cn/opensource/os-cn-pythonwith/
11. https://www.cnblogs.com/alamZ/p/6943869.html