Python学习2

9月18日：Python面向对象高级编程

用__sloths__（特殊变量，非private）来限制类变量可以绑定的属性名称

但它仅对当前类的实例起作用，对该类的子类实例是不起作用的，需要时在子类中添加__sloths__即可

class Classmates(object):
    # 用tuple定义允许绑定的属性名称
    __slots__ = ("name", "age")


print("----------Classmates----------")
classmate1 = Classmates()
classmate1.age = 20
classmate1.name = "Elizabeth"
print(classmate1.name, classmate1.age)

@property 可以把方法作为属性调用，使用起来十分方便

@属性名.setter 负责把一个属性的setter()方法变为属性赋值

class Student(object):
    _score = 0
    # 这个属性为只读属性
    _score_lost = 0

    @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("Score must between 0 - 100!")
        self._score = value

    @property
    def score_lost(self):
        return 100-self.score


student = Student()
# 相当于调用了
student.score = 99
print(student.score)
print(student.score_lost)

这个链式类写的也太美了吧...

# chain calls
class Chain(object):
    # learn a new way to declare the non class-variables with default value
    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    # print出的类实例会更好看
    def __str__(self):
        return self._path


print(Chain().status.user.timeline.list)

# 带参数的URL

学习到枚举类让我有一种重构代码的冲动

不过不急，先把功能用笨方法实现，后期再慢慢优化，肯定有更高级的用法在等着我，我想成为高级玩家！！！

以下是用枚举类来实现将一组相关常量定义的两种办法，第二种是自定义了一个Enum的派生类，也就是子类

from enum import Enum, unique

# one method
Weekday = Enum('weekday', ('Monday', 'Thursday', 'Wednesday', 'Tuesday', 'Friday'))
for name, member in Weekday.__members__.items():
    # value attribute is applied automatically, which is int type counting from 1
    print(name, '=>', member, ',', member.value)


# unique method
@unique
class Weekdays(Enum):
    Sun = 0
    Mon = 9
    Tue = 2


print(Weekdays.Mon)
print(Weekdays['Mon'].value)
# attention! the value in the parenthesis means the number on the right side of equal sign
# rather than the sequence#
print(Weekdays(0))


@unique
class Gender(Enum):
    Male = 0
    Female = 1


class Student(object):
    def __init__(self, gender):
        self.gender = gender


student = Student(Gender.Female)
print(student.gender)

总算学完了，还算有点复杂，离熟练使用还有很长一段距离emmmm，加油吧

metaclass这里我没有学，以后有需要再回顾，复杂且难呢

不过终于弄懂了什么是ORM(Object-Relation Mapping)

对象关系映射

也就是将关系型数据库中的一张表和某一个类对应起来，表中的每一行与该类的某个对象联系起来

估计之前铁帅课上学的Hibernate就是这样实现的？？(少壮不努力，老大徒伤悲啊)

--------------------------9月27日-------------------------------

time flies 时间过得太快了

发现了一个学习的好去处，library

我可以边用大屏的mac边看着敲代码哈哈 很爽

所以以后我的schedule就变成了 9点以后去library学习1小时之后再回去

昨天依旧学习的Python基础 正则表达式

我觉得这个还是非常重要的也是很常用的 不过只学了点皮毛 深入学习的话还是要下一番功夫的

印象比较深刻的点总结如下：

1、可以用()把需要的部分字符串提取出来，这个很方便

2、^表示行头 $表示行尾

3、引入Python的re模块

4、正则表达式是会被编译之后再去制定的字符串去匹配的，如果某个regular expression需要被频繁用到，可以预编译

5、贪婪匹配：可以通过加  ?   让匹配变得不贪婪

6、match成功返回的是被match成功的字符串对象，调用.groups()方法可以得到整个字符串；失败返回的是none

实践的代码如下：

import re
print('ABC\\-001')
re_match = re.compile('^(\d{3})\-(\d{3,8})')


def match_method(test):
    # invoke the re.match() method will return a match object or none
    result = re_match.match(test)
    return result


test1 = '809-98787'
m = match_method(test1)
print(m.group(0))
print(m.group(1))
print(m.group(2))
# re default situation is using greedy match
print(re.match('^(\d+?)(0*)$', '103210').groups())
print(re.split('[\s\,\;]+', 'a  b,;  c'))

我还是不清楚 Python 当中r 这个prefix有啥作用，因为我加了和没加都是一样的效果......