python基础中的基础知识点

本人菜鸟，如果写的有问题，望指正~~~

1.计算机执行过程

计算机只能识别机器码（010101），无法识别源代码
由源代码变成机器码的过程分为两类：编译和解释
编译：在程序运行之前，通过编译器将源代码变成机器码，例如：c语言。优点：开发速度快。缺点：开发效率低，不能跨平台
解释：在程序运行之时，解释器对程序逐行翻译，饭后执行。优点：开发效率高，可以跨平台。缺点：运行速度慢

2.python是解释型语言

为了提高运行速度，使用了一种编译的方法。编译之后得到了pyc文件，存储了字节码（特定于python的变现形式，不是机器码）源代码—编译—字节码—解释—机器码

3.解释器类型

CPython，Jython,IronPython(.net)

4.关于编码的内建函数

ord(字符串)：返回该字符串的Unicode码
chr(整数)：返回该整数对应的字符串

5.关于字符串格式化

'%%'%('张三','李四')
'{}{}'.format('张三','李四')
'张三'+'李四'
list01 = ['张三','李四']  str01 = ''.join(list01)

6.关于python的列表的机制

列表是由一系列变量组成的可变序列容器，每次都会事先开辟出更大的空间。
自动扩容机制：
1.开辟出更大的空间。
2.拷贝原始数据。
3.替换引用
优点：运行时根据需求储存数据
缺点：产生垃圾

7.链表

内存不是连续的，每个节点保存下一个节点的内存地址。
不用事先开辟空间，灵活

8.深浅拷贝

浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。

9.字典，集合以及hash

字典，集合，redis的hash结构都是根据哈希运算来存储的

字典集合：
1.初始化一个空字典d={}
2.在该字典里插入key a
3.根据哈希运算的值结果去指定的索引位置上尝试存储d['a'] = value
4.如果该位置已经有数据，则出现哈希碰撞，于是引出了开放地址法，重新计算该值得位置。假如原来计算出的哈希值为1，则hash（1+偏移量）=3
5.扩容：若已经使用的座位数大于总位数的三分之二，则会扩容4倍，若当前座位数大于5w，则扩容2倍，扩容后座位重新排列
6.查找：hash（‘a’）%32 = 0，如果遇到特殊标记dummy（字典删除key时，当前座位标记为dummy），进行开放地址法继续查找

redis的hash结构

哈希碰撞：单链法，在碰撞位置上，垂直方向开辟存储空间，按顺序生成座位
扩容：used/len（数组-横着的）>1，可能会扩容，>5 必然扩容
第一个大于used*2的2的n次方；2*2 = 4，第一个2**n>4，即8，rehash--->渐进式rehash，新旧两个座位表

10.类和对象

类是创建对象的模板。
类是一个抽象的概念，即生活中的类别。
对象是类的具体实例，即归属于某个类别的个体。

类成员：

类变量：
即在类中，方法外定义的变量，通过类名.变量名调用
存储在类中，被所有对象所共享
类方法：
@classmethod
def 方法名称（cls，*args）：
	方法体
通过类名.方法名调用

11.设置读写属性

读取写入属性。（快捷键：props）
class MyClass：
	def __init__(self,data):
		self.data = data
	
	@property
	def data(self):
		return self.__data
	
	@data.setter
	def data(self.value)
		self.__data = value

只读属性（快捷键：prop）
class MyClass：
	def __init__(self,data):
		self.data = 1000
	
	@property
	def data(self):
		return self.__data

只写属性
class MyClass：
	def __init__(self,data):
		self.data = data
	
	data = property()
	
	@data.setter
	def data(slef,value):
		self.__data = value

12.静态方法

静态方法一般用于定义一些常用的工具函数。且无法访问实例成员和类成员，通过类名.方法名调用

@staticmethod
def fun(*args,**kwargs):
	方法体

13.面向对象三大特征

封装，继承，多态

封装：讲数据与数据的操作相关联，使代码的可读性更高。向类外提供必要的功能，隐藏实现的细节。私有变量或者方法可以加__开头进行屏蔽
为了方便代码的维护与修改，从设计角度来看，封装提现了分而治之、变则疏之、高内聚、低耦合的思想。

继承：子类直接具有父类的成员，还可以拓展新功能，是一种代码复用的方式。在子类的构造函数中添加super().__init__(参数)。
子类如果没有构造函数，将自动执行父类的，但如果有，将覆盖父类的，需要super（）函数调用父类的，来确保父类的实例变量被正常创建。
但是继承的耦合度比较高，父类变化会影响子类。

多态：多态指的是父类的童一种行为，在子类上有不同的提现。提现类型的个性化，增强扩展性，体现了开闭原则。
另一个表现是重写，子类中实现了父类中相同的方法名，改变其行为。

14.内置可重写函数

在python中，以双下划线开头、双下划线结尾的是系统定义的成员，可以在自定义类中进行重写。

__str__函数：将对象转换为字符串，通常展现给人看（Django的模型类中有经常用）
__repr__函数：将对象转换为机器可识别的字符串，通常与eval（）一起使用，能将字符串作为python代码执行

还有运算符重载，比较运算符重载等等。

15.面向对象设计原则

开闭，单一职责，依赖倒置，组合复用，里式替换，迪米特法则。
一般在开发过程中，都是先写父类，再写子类。
但是在架构设计角度，父类是根据子类抽象出来的

16.迭代

具有__iter__函数的对象，可以返回迭代器对象
可迭代对象都有__next__()方法

17.生成器

能够动态的提供数据的可迭代对象，不必创建容器存储完整的结果，节省内存空间，数据量大的时候很明显。
生成器=可迭代对象+迭代器 yield
(1) 调用生成器函数会自动创建迭代器对象。
(2) 调用迭代器对象的__next__()方法时才执行生成器函数。
(3) 每次执行到yield语句时返回数据，暂时离开。
(4) 待下次调用__next__()方法时继续从离开处继续执行。

原理：生成迭代器对象的大致规则如下
– 将yield关键字以前的代码放在next方法中。
– 将yield关键字后面的数据作为next方法的返回值。

18.内置生成器

枚举函数：enumerate
for i in enumerate(iterable):
	pass
遍历可迭代对象时，可以将索引与元素组合为一个元组

zip函数
for item in zip(iterable1,iterable2):
	pass
将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定

19.内置高阶函数

map(函数，iterable):使用iterable中的每个元素调用函数，将返回值作为新的iterable。
filter(函数，iterable ):根据条件筛选可迭代对象中的元素，返回值为新的iterable。
sorted（iterable,key=函数，reverse=True/False）:排序，返回值为排序结果。
max/min(iterable,key=函数)：根据函数获取iterable中的最大值/最小值

20.函数作为返回值

闭包：
作用：保留外部函数的栈桢，供内部函数使用
作用：逻辑连续

装饰器
def function(func):
	def wrap(*args,**kwargs):
		......功能
		return func(*args,**kwargs)
	return wrap

property也是一种内置的装饰器