python面向对象知识点总结_python面向对象编程，知识点总结

字符中常见的内置方法 (可以用 dir(str) 来查) 有

capitalize()：大写句首的字母

split()：把句子分成单词

find(x)：找到给定词 x 在句中的索引，找不到返回 -1

replace(x, y)：把句中 x 替代成 y

strip(x)：删除句首或句末含 x 的部分

正则表达式示例说明：

pattern = re.compile("’[0-9/:\s]+’")

抽象模式表达式 ‘[0-9/:\s]+’，里面符号的意思如下：

最外面的两个单引号 ’ 代表该模式以它们开始和结束

中括号 [] 用来概括该模式涵盖的所有类型的字节

0-9 代表数字类的字节

/ 代表正斜线

: 代表分号

\s 代表空格

[] 外面的加号 + 代表 [] 里面的字节出现至少 1 次

对于含单个元素的元组，务必记住要多加一个逗号

eg: print( type( (‘OK’,) ) ) # 有逗号

通配符 *

元组大小和内容都不可更改，有 count 和 index 两种方法

列表内容可更改 (mutable)，因此有 count、index 、append(追加), extend(扩展)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

列表和元祖比较：

列表相对于元祖灵活好用，可索引、可切片、可更改、可附加、可插入、可删除。但比 tuple 创建和遍历速度慢，占内存。此外查找和插入时间较慢。

字典里最常用的三个内置方法就是 keys(), values() 和 items()，分别是获取字典的键、值、对。keys values items

集合有两种定义：1.{元素1, 元素2, …, 元素n} 2. set( 列表 或 元组 ) 集合的特点是无序和唯一

函数中：

*args - 可变参数，可以是从零个到任意个，自动组装成元组。

**kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

*, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。

lambda 函数没有所谓的函数名 (function_header)，这也是它为什么叫匿名函数

eg:

func = lambda **kwargs: 1

func( name=‘Steven’, age=‘36’ )

高阶函数 (high-order function) 在函数化编程 (functional programming) 很常见，主要有两种形式：

参数是函数 (map, filter, reduce)(不建议使用，用解析式替代)

返回值是函数 (closure, partial, currying)

map(函数 f, 序列 x)：对序列 x 中每个元素依次执行函数 f，将 f(x) 组成一个「map 对象」返回 (可以将其转换成 list 或 set)

filter(函数 f, 序列 x)：对序列 x 中每个元素依次执行函数 f，将 f(x) 为 True 的结果组成一个「filter 对象」返回 (可以将其转换成 list 或 set)

reduce(函数 f, 序列 x)：对序列 x 的第一个和第二个元素执行函数 f，得到的结果和序列 x 的下一个元素执行函数 f，一直遍历完的序列 x 所有元素。在 reduce 函数的第三个参数还可以赋予一个初始值

偏函数 eg: from functools import partial sorted_dec = partial( sorted, reverse=True )

柯里化 参数最小化

解析式

python中调用方法有两种情况，与C++有不同：对象.方法() 类.方法(对象)

如果想让类变量千人千面，用 self.类变量

如果想让类变量千人一面，用 类名.类变量

类方法是所有对象和类都能调用，而且产生的效果是一样。

第一行要有装饰器 @classmethod (记住就行了)

函数第一个参数必须是关键词 cls (对象一个参数必须是关键词 self)

一个类还会有些效用函数 (utility function)，它们不随对象和类的属性而改变，因此我们称它们为静态方法。

第一行要有装饰器 @staticmethod (记住就行了)

函数参数绝对不能有关键词 clf 和 self

查看某的详细帮助可以：help(某)

函数 isinstance(a, A) 是检查 a 是不是 A 的一个实例;

函数 issubclass(A, B) 是检查 A 是不是 B 的一个子类。

魔法方法 (magic method) 的方法名前后被双下划线 (dunder) 所包围，构造函数 init 就是最常见的魔法方法。

其实所有类都是 object 类的子类，而 object 类里有两个重要的魔法方法，repr 和 str，任何 object 的子类都会继承这两个方法。

魔法方法 add 重载了二元运算符 +。

属性装饰器 (property decorator) 只用加一句 @property。这样所有方法都可以当成属性用，即调用它们时不用打括号了

@fullname.setter

------------------------------------------------

class Employee:

raise_rate = 1.05

def __init__(self, first, last, pay):

self.first = first

self.last = last

self.pay = pay

self.email = first + '.' + last + '@gmail.com'

def fuilname(self):

return '{} {}'.format(self.first, self.last)

def apply_raise(self):

self.pay = int(self.pay*self.raise_rate)

def __repr__(self):

return 'Employee(\'{}\',\'{}\',{})'.format(self.first, self.last, self.pay)

def __str__(self):

return '{} - {}'.format(self.fuilname(), self.email)

def __add__(self, other):

return self.pay + other.pay

class Developer(Employee):

raise_rate = 1.1

def __init__(self, first, last, pay, prog_lang):

super().__init__(first, last, pay)

self.prog_lang = prog_lang

class Manager(Employee):

def __init__(self, first, last, pay, employees = None):

super().__init__(first, last, pay)

if employees == None:

self.employees = []

else:

self.employees = employees

def add_emp(self, emp):

if emp not in self.employees:

self.employees.append(emp)

def remove_emp(self, emp):

if emp in self.employees:

self.employees.remove(emp)

def print_emp(self):

for emp in self.employees:

print('-->', emp.fuilname())

emp_1 = Employee('steven', 'wang', 20000)

emp_2 = Employee('sherry', 'zhang', 10000)

print(emp_1 + emp_2)

#print(emp_1.pay)

#emp_1.apply_raise()

#print(emp_1.pay)