find /etc -name "*.conf" -> 在etc目录下面查找conf文件
grep -> 查找字符串
面向对象四大支柱：抽象、封装、继承、多态
抽象 - 定义类的过程就是提取共性的抽象过程
数据抽象 - 找到对象的静态特征 - 属性 - 找名词
行为抽象 - 找到对象的动态特征 - 方法 - 找动词
封装 - 将数据和操作数据的方法从逻辑上组成一个整体 - 对象
隐藏实现细节 暴露简单的调用接口
继承 - 从已有的类创建新类的过程
提供继承信息的称之为父类，得到继承信息的称之为子类
多态 - 调用相同的方法，做了不同的事情
同样的方法在运行时表现出不同的行为
子类重写父类方法，不同的子类给出不同的实现版本
抽象类：在抽象类中声明的抽象方法必须要在子类中实现，抽象方法不能被继承
class Employee(object, metaclass=ABCMeta):
@abstractmethod
def ……
查找替换：
/ 进入末行模式，输入查找内容 小写n往下搜索，大写N往上搜索
:1,$ 从第一行到最后一行
:1,$s/self/shit 从第一行到最后一行,找到self替换成shit (s:substitute)
:1,$s/self/shit/c 从第一行到最后一行,找到self替换成shit,并需要进行确认
:1,$s/self/shit/ci 从第一行到最后一行,找到self替换成shit,并需要进行确认，同时忽略大小写（i:ignore case)
名词：扑克 玩家 牌
动词：洗牌 发牌 摸牌
类和类之间（对象之间）的关系：
- is-a关系 - 继承
- has-a关系 - 关联（学生有笔记本电脑）/聚合/合成 （（强关联）小汽车有引擎：聚合或者合成）
- use-a关系 - 依赖
面向对象七个设计原则：
1.单一职责原则 - 一个类只做该做的事情，不做不该做的事情
2.开闭原则
3.依赖倒转原则
4.里氏替换原则
5.接口隔离原则
6.合成聚合复用原则 - 优先考虑强关联关系而不是继承关系来复用代码
7.最少知识原则（迪米特法则）
设计模式：
GoF设计模式（23种经典场景，有17种在python中被弱化了（因为是动态弱类型语言））
！经验： 符号常量优于字面常量，枚举类型是定义符号常量的最佳选择
SPADE.value可以取到常量的值，Suite是可以迭代的类型
class Suite(Enum):
SPADE = 0
HEART = 1
CLUB = 2
DIAMOND = 3
__repr__:
对象作为列表的元素时，打印自动调用__repr__
def func1(a, *, key='')
*前面的参数称为位置参数（传参时不用指定参数名，按位置对号入座即可）
*后面的参数称为命名关键字参数（传参时必须给出参数名和参数值）
工资结算系统：
#!/usr/bin/python3
from abc import ABCMeta, abstractmethod
class Employee(object, metaclass=ABCMeta):
def __init__(self, name):
self.name = name
@abstractmethod
def get_salary(self):
pass
class Manager(Employee):
def get_salary(self):
return 15000
class Programmer(Employee):
def __init__(self, name):
self.working_hour = 0
super().__init__(name)
def get_salary(self):
return 200 * self.working_hour
class Salesman(Employee):
"""销售员"""
def __init__(self, name):
self.sales = 0
super().__init__(name)
def get_salary(self):
return 1800 + self.sales * 0.05
def main():
emps = [
Manager('曹操'), Programmer('荀彧'),
Programmer('郭嘉'), Salesman('张辽')
]
for emp in emps:
if isinstance(emp, Programmer):
hour = int(input(f'请输入{emp.name}本月工时：'))
emp.working_hour = hour
elif isinstance(emp, Salesman):
sales = float(input(f'请输入{emp.name}本月销售额：'))
emp.sales = sales
print(f'{emp.name}本月工资为：{emp.get_salary()}元')
if __name__ == '__main__':
main()
扑克游戏：
#!/usr/bin/python3
from enum import Enum, unique
import random
# 经验： 符号常量优于字面常量，枚举类型是定义符号常量的最佳选择
# SPADE.value可以取到常量的值，Suite是可以迭代的类型
@unique
class Suite(Enum):
"""花色的枚举"""
SPADE = 0
HEART = 1
CLUB = 2
DIAMOND = 3
class Card(object):
def __init__(self, suite, face):
self.suite = suite
self.face = face
def show(self):
suites = ['黑', '红', '梅', '方']
faces = [
'', 'A', '2', '3', '4', '5', '6',
'7', '8', '9', '10', 'J', 'Q', 'K'
]
return f'{suites[self.suite.value]}{faces[self.face]}'
def __str__(self):
return self.show()
def __repr__(self):
return self.show()
"""
def __gt__(self, other):
if self.suite == other.suite:
return self.face > other.face
return self.suite.value > other.suite.value
"""
class Poker:
def __init__(self):
self.index = 0
# 生成式/推导式
self.cards = [Card(suite, face)
for suite in Suite
for face in range(1, 14)]
def shuffle(self):
"""洗牌"""
random.shuffle(self.cards)
def deal(self):
"""发牌"""
card = self.cards[self.index]
self.index += 1
return card
@property
def has_more(self):
"""是否还有更多的牌"""
return self.index < len(self.cards)
class Player(object):
"""玩家(与牌既有关联关系，又有依赖关系)"""
def __init__(self, name):
self.name = name
self.cards = []
def get_one(self, card):
"""摸一张牌"""
self.cards.append(card)
def sort_cards(self, key=lambda card: (card.suite.value, card.face)):
"""玩家整理手上的牌"""
self.cards.sort(key=key)
def main():
poker = Poker()
poker.shuffle()
print(poker.cards)
players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
for _ in range(13):
for player in players:
player.get_one(poker.deal())
for player in players:
player.sort_cards(key=lambda card: (card.face, card.suite.value))
print(player.name, end=': ')
print(player.cards)
if __name__ == '__main__':
main()
