python-知识点总结（二）

函数

1、在.py文件中以def 开头定义，不在类中定义的是函数；类中定义的是方法
2、函数封装独立的功能，可直接调用
3、函数有内置函数、匿名函数等
4、函数可以利用元组返回多个值。如果函数返回的类型是元组，可省略小括号
5、当函数返回多个值时，可以使用元组下标方式获取值，也可以定义多个变量来接受函数返回值

def demo():
	a =1
	b=2
	return a,b
gl_a,gl_b = demo()
print(gl_a)
print(gl_b)

高阶函数

1、高阶函数就是在一个函数里，参数可以传递函数，或者一个函数的返回值为另外一个函数

def add(x,y,f):
    return f(x)+f(y)
print add(2,3, lambda x:x**2)

2、python内置高阶函数
（1）sorted函数，按指定元素进行排序

obj = [[1,2], [5,6], [2,8], [8,3], [3,10]]
func = lambda x: x[1]
new_list = sorted(obj, key=func, reverse=False)
print(new_list)  # [[1, 2], [8, 3], [5, 6], [2, 8], [3, 10]]

（2）filter函数

obj = filter(lambda x: x > 0, [-20, -10, -1, 0, 1, 10, 20])
print(obj) # <filter object at 0x004C9EB0>

for i in obj:
    print(i) # 1 10 20

（3）map函数

#函数映射
obj = map(lambda x: x+1, [0,6,10])
print(obj) # <map object at 0x0026DDB0>
for i in obj:
    print(i) # 1 7 11

#封包传递
obj2 = map(lambda x, y: x+y, *([0, 5, 8], [2, 2, 2]))
print(obj2)  # <map object at 0x0076FE90>
for i in obj2:
    print(i)  # 2 7 10

内置函数

1、查看所有内置函数或者内置变量

import builtins
print(dir(builtins))

2、dir() 查看对象的属性和方法
3、eval(“”) 执行字符串参数编译后的代码
4、abs(x) 返回一个数的绝对值
5、bin(x)将一个整数转变为一个前缀为“0b”的二进制字符串
6、divmod(a, b) 它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。
7、hash(object) 返回该对象的哈希值（如果它有的话）。哈希值是整数。
8、id(object)返回对象的“标识值”,可返回对象的内存地址
9、isinstance(object, classinfo)
10、len(s):计算容器中元素的个数
11、max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的
12、min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
13、next(iterator[, default])
通过调用 iterator 的 next() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。
14、print(“”，end="\d")

匿名函数

1、语法：lambda 参数列表 : 表达式
2、所谓匿名函数，就是没有名字的函数。
3、匿名函数冒号后面的表达式有且只能有一个
4、匿名函数自带return，而return的结果就是表达式的计算后的结果。

缩进

1、.py文件中的缩进格式必须相同，否则会报错

函数嵌套调用

递归

1、在函数内部自己调用自己
2、递归出口：当参数满足某个条件时，函数不在执行

返回值

参数

1、

def user(username):   //username 是形参，不占用内存地址
    print("Hello World,"+username)　

user(‘asd’) //asd 是实参，占用内存地址

实参

1、实参占用内存空间
2、函数调用时，本质上传递的是实参保存数据的引用，而不是实参保存的数据；实参通过引用给形参传值

形参

1、形参不占用内存空间

位置实参

user(‘asd’) // 将实参和形参 按照位置对应起来

关键字实参

user(username = ‘asd’) 通过关键字=值的方式，将实参与形参关联映射，不需要考录形参的顺序

缺省参数（默认值）

1、给形参设置默认值，调用函数或者方法是可以不再给形参传值
2、带有默认值的参数必须在没有默认值参数的后面定义

多值参数

1、有时候需要一个函数可以处理的参数个数是不确定的，这时可使用多值参数
2、Python有两种多值参数
参数名前一个* ，可接收元组
参数名前两个**，可接受字典
3、多值参数命名习惯：*args,**kwargs
4、调用函数时，传参写法

def demo(*num,**mi):
	print(sum(num))
	print(mi)
s = (1,2,3)
m  = {"s":3}
demo(*s)
demo(**m)
demo(1,2,3,4,num=3,go=4)

拆包

1、拆包是指将一个结构中的数据拆分为多个单独变量中
2、拆包可简化参数的传递
3、拆包一种是以变量的方式来接收

a,b,c =("s","m","n")

4、拆包的另一种方式 用*号

a = [1,2,3]
print(*a)

单行注释

“” 或者’’

多行注释

“”“多行注释，可换行”""

TODO 注释

用于标记未完成代码

文档注释

模块

1、一个.py文件就是一个模块
2、模块

import

1、_x是私有化变量或者私有化方法，import不可导入,但是类对象或者子类可以使用；__xx:类中的私有变量，类对象或者子类不可使用；
2、import 能防止模块重复导入
3、重新导入模块

from importlib import reload
import sys
reload(sys)

traceback

1、打印堆栈信息

import trackback
trackback.print_exc()

类

1、类的三要素：类名、属性、方法

class  A(object):  //类对象
	aa  =  1 //类变量（类属性）
	__bb  =  "sd"  //私有变量（类属性）
	def  __init__(self,name):  //构造方法
		self.name  =  name  //实例变量
		A.aa += 1 
		print(aa)

	def  __pp(self):  //私有方法
		print  AA  

	@classmethod  //python装饰器
	def  pri(cls):    //类方法
		print  cls.aa
		print  cls.bb

	@staticmethod
	def  ll():  //静态方法
		print  A.aa

a = A()   	//实例对象
A.aa // 访问类属性
A.pri() //访问类方法

2、类名命名规则：单词首字母大写，单词和单词之间没有下划线
AdStats
ConfigUtil
3、类是一个对某一类具有共同特点的事物的抽象，只是概念，不代表一个具体的个体
4、类也是对象，当定义类、全局变量、函数时，其实就是创建了一个对象，然后globals获取的这个字典中添加对象名，并让这个对象名指向对象空间。
5、元类创建类，类创建实例对象

新式类

1、继承Object
2、在py3中定义的类都是新式类，如果没有指定父类，会默认使用object作为该类的基类
3、为了保证编写的代码能同时在py2和py3中运行，建议统一继承object
4、新式类和经典类在多继承时，会影响到方法的搜索顺序。
python的类如果继承了多个类，其寻找方法的方式有两种，分别是广度优先和深度优先。当类是经典类时，多继承情况下会按照深度优先的方式查找；当类是新式类时，多继承情况下会按照广度优先的方式查找。

旧式类

1、不继承Object
2、在py2中，如果没有指定父类，则不会以object作为基类

对象

python中对象无处不在，变量、数据、函数都是对象
证明方法：
（1）在标识符/数字后输入. 会提示该对象可调用的常用方法列表
（2）使用内置函数dir() 可查看对象内的所有属性和方法

实例对象

1、通过a = A() 来创建实例对象,a 仍然引用的是对象在内存中的地址
2、在计算机中用16进制数表示内存地址
3、使用类名()创建对象时，python的解释器会先调用__new__方法为对象分配内存空间并返回对象的引用，然后调用__init__方法初始化对象的属性
重写new方法可实现单例，__new__一定要返回super().new(cls),如果没有返回对象引用，就不会调用__init__方法

类对象

1、python中一切都是对象，类是特殊的对象。在程序运行时，类同样会被加载到内存中。
2、类对象除了封装的属性和方法外，类对象还有自己的属性和方法，叫类属性和类方法

面向对象

1、面向对象是一种以对象为基础，以事件或者消息来驱动对象执行处理的程序设计思想。
面向过程面是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个调用就可以了。
2、面向对象特征：封装、基础、多态、抽象
3、面向对象和面向过程的区别：
a、考虑问题的出发点不同。面向过程是以事物流程为考虑问题的出发点，面向对象则以参与事件的角色（对象）为考虑问题的出发点。
b、从结构上讲，面向过程的特点是模块化和流程化；而面向对象的特点是封装、继承和多态。
c、面向过程程序流程在写程序时就已经确定了；面向对象程序流程由用户在使用中决定。

封装

1、 根据职责将属性和方法封装到一个抽象的类中

单继承

1、继承：子类拥有父类的所有属性和方法
2、语法：

class 类名（父类名）：
	pass

3、继承的好处：实现代码的重用，相同的代码不需要重写
4、继承具有传递性
5、如果子类不实现__init__()，初始化时调用父类的初始化函数，如果子类实现这个函数，就覆盖了父类的__init__();如果要继承父类的初始化方法，就要在这个函数里显式调用一下父类的__init__()
supper().__init(参数)
6、子类调用父类的属性和方法

class Animal(object):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print("annimal吃")

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)  
        self.toll = "sdas"

    def eat(self):
      	super().eat()  //调用父类的方法
        print("%s吃" %self.name)  //调用父类的属性
        print(self.toll)
c = Cat("猫咪")
c.eat()

7、python实现继承的原理：python对于定义的每个类，python会计算出一个方法解析顺序列表（MRO），这个MRO列表就是一个简单的所有方法的线性顺序列表。

多继承

1、定义：

class 类名（父类名1,父类名2）：
	pass

2、查看继承：
子类.base :只能查看从左到右继承的第一个父类 (<class ‘main.ParentClass1’>,)
子类.bases :能查看所有继承的父类 (<class ‘main.ParentClass1’>,<class ‘main.ParentClass2’>)

super

1、Super是python中的特殊类，super()就是使用super类创建出来的对象。
2、调用父类的方法：super().父类方法
还有一种调用父类方法：父类名.方法(self),但是不推荐使用
3、子类继承父类的初始化方法：如果子类初始化时没有定义__init()()，那么它便调用父类的__init()；如果子类实现了这个函数，就会覆盖父类的初始化函数。如果继承父类的__init__()，就需要在子类中使用super()显示调用父类的__init__(), super().__init()。子类也可以在初始化函数中定义自己的属性。

MRO方法搜索顺序

重写

重写的两种情况
1、覆盖父类的方法：父类的方法实现和子类的方法实现完全不同，就在子类中定义一个和父类同名的方法并实现

2、扩展父类的方法：子类的方法实现中包含父类的方法实现，在子类中重写父类的方法，在需要的位置使用super().父类方法来调用父类方法执行，代码的其他位置编写子类的代码

多态

1、多态的前提是继承和重写

class Animal(object):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print("动物吃")

class Cat(Animal):

    def eat(self):
        print("猫咪吃")

class People(object):
    def __init__(self, animal):
        self.animal = animal

    def play(self):
        print("人和动物玩耍")
        self.animal.eat()

a = Animal("动物")
c = Cat("猫咪")
p1 = People(a)
p1.play()
p2 = People(c)
p2.play()

接口
抽象类
dir()

成员变量（实例变量、对象变量、成员属性）

1、属性定义在__init__()方法中
2、在类的外部给对象添加属性，直接用 对象名.name=“s”
不推荐使用，因为对象的属性应该封装在类的内部
3、在成员方法内用self.可访问成员变量
4、在类外部使用对象.访问成员变量
5、一个对象的属性可以是另一个类创建的对象

私有属性（私有变量）

1、定义方式 __变量名
2、私有变量只能在类内部通过self.访问，类外部不可以访问
3、类外部可以通过类的非私有方法访问私有变量
4、python将 __变量名 转换成了_类名__变量名，使用这种可以在类外访问私有变量（不建议这么操作，道德问题）

类属性（类变量）

1、定义在class下方，方法的外面
2、在类外面可通过类名.访问，也可以通过对象名.访问

class A(object):
    a = "s"
    def s(self):
        print(A.a)

    @classmethod
    def b(cls):
        print(cls.a)
print(A.a)
m = A()
print(m.a)

3、在内的内部可通过类名.访问，也可以通过cls.访问，

class A(object):
    a = "s"
    def s(self):
        print(A.a)

    @classmethod
    def b(cls):
        print(cls.a)
m = A()
m.s()
m.b()

3、类属性就是类对象中定义的属性；通常用来记录与这个类相关的特性。类属性不会记录具体对象的特征

方法

1、类中定义的叫作方法，类外定义的是函数
2、常见的方法有成员方法、静态方法、类方法、私有方法、内置方法

成员方法

1、在类中定义，通过对象来调用，表示针对这个对象做操作
对象.方法名（参数）
2、类中定义方法

class A(object):
	def a(self,*arg,**kwargs)
		pass

3、self代表当前对象，存储的是内存管理中对象的地址
4、同一个类的多个对象的方法在内存中只保存一份，在类内存中。每个对象都有自己独立的内存空间，保存各自不同的属性。多个对象的方法在内存中只保存一份。在调用方法时，需把对象的引用传递到方法内部

类方法

1、定义方式

@classmethod  //修饰符
def 类方法(cls):
	pass

2、cls 是类引用，说明是哪个类调用的方法。
3、在类方法内部使用cls.访问类属性和调用其他类方法，不能访问对象属性和对象方法,可以访问静态方法

私有方法

1、定义方式

def __a():
	pass

2、私有方法只能在类内部调用，不能通过实例调用

静态方法

1、定义方法：

@staticmethod
def sds():
    print("sds")

2、不能访问对象属性、对象方法、类方法
3、调用方法：类名.静态方法

内置方法

1、内置方法的格式__方法名__()
2、new() 创建对象时给对象分配内存空间,是object基类提供的内置的静态方法。
3、init(self) 是初始化函数，也叫构造函数，创建对象时会首先执行
4、del() 对象被从内存中销毁前，会被自动调用
5、str() 返回对象的描述信息，print函数输出使用。类似java的toString（）方法，让class作用于print（）函数
在python 中输出对象变量时会输出变量的引用对象是由哪个类创建的对象及对象在内存中的地址（16进制表示）；如果想要输出自定义的内容，需重写__str__方法，str__必须返回一个字符串。
6、repr() 返回程序开发者看到的字符串
7、iter() 不重写这个方法就不能做索引
实际上只要类实现了__iter() getiter() next()方法就可以做索引，否则不能索引，字符串、列表、元组等实现了这三个方法。
8、call() 将一个类变成一个函数，使这个类的实例可以像函数一样调用

class A():
    def __init__(self, k, b):
        self.k = k
        self.b = b

    def __call__(self, x):
        print(self.k*x + self.b)
a = A(1, 2)
a(1)
a(3)

闭包

def line(k, b):
    def create_y(x):
        print(k*x + b)
    return create_y

m = line(12, 21)
m(0)

异常

1、语句

import traceback  //引入堆栈包
try:
   	pass  //可能会发生异常的语句
except （IndexError，NameError）as e:
  	//出现异常后执行的语句
	 print e //打印异常信息
	trackback.print_exc() //打印堆栈信息
	return 0 //执行完后会执行finally
else:
	pass  // 没有发生异常时执行的语句
finally:
	pass  //不管有没有发生错误，都执行的语句

2、自定义抛出异常
raise Exception(‘自定义异常’)
3、当函数出现异常时，会将异常传递给函数的调用方。如果传递到主程序，仍没有异常处理，程序才会被终止。
4、在开发中，可以在主函数中增加异常捕获，这样就不需要在代码中增加大量的异常捕获，保证代码的整洁
5、python中的异常都是对象，基础类是BaseException
6、常见异常：
#ImportError 导入模块错误
#IndexError 索引超出范围
#KeyError 字典中key不存在
#NameError 变量没定义
#IndentationError 缩进错误
#SyntaxError 语法错误
#TypeError 不同类型间的无效操作
#ZeroDivisionError 除数为0

调试

发布模块

=制作发布模块（就是模块共享）============
1.创建setup.py文件
From distutils.core import setup

setup(name=‘Distutils’,
version=‘1.0’,
description=‘Python Distribution Utilities’,
author=‘Greg Ward’,
author_email=‘gward@python.net’,
url=‘https://www.python.org/sigs/distutils-sig/’,
packages=[‘distutils’, ‘distutils.command’],
)

2、构建模块
Python3 setup.py build

3、生成发布压缩包
Python3 setup.py sdist

=安装模块============
tar -zxvf .tar.gz
sudo python3 setup.py install

=卸载模块============
cd 目录
sudo rm -rf *

包

1、包是包含多个模块的特殊目录，目录下有一个特殊的文件__init__.py文件
2、使用包下工具的两种方式
第一种：
from blade.logger import infoLogger as log
第二种：
第一步：在blade 包下的__init__.py文件中指定对外界提供的模块列表
From . Import logger
第二步：Import blade
第三步：访问blade.logger.infoLogger

文件读写

1、f = open(file_path, mode, encoding=‘utf-8’,errors=’’ ) 返回文件对象（文件句柄）
2、f.read() 一次性读取并返回文件的所有内容
3、f.readline() 一行一行读取文件
4、f.write()
5、f.close()
6、with open(file_path) as file1 可以避免打开文件后忘记关闭，占用资源或当不能确定关闭文件的恰当时机的时候，不用特意关注关闭文件
7、f.readlins() 将每一行形成一个元素，放到一个列表中，将所以的内容全部读出来，如果文件很大，占内存，容易崩盘。
8、f.seek(n) 移动光标位置
9、f.tell() 查看光标位置
10、为open指定errors = ，出现编码错误时，'strict’引发ValueError异常
‘ignore’忽视异常
11、为open指定 buffering =
文件的io操作的缓冲行为有
全缓冲：同系统及磁盘块大小有关，n个字节后执行一次写入操作
行缓冲：遇到换行符执行一次写操作
无缓冲：立刻执行写操作
buffering默认为-1，系统默认的全缓冲
buffering可以设置为大于1的任意整数，字节数为buffering的全缓冲
buffering=1，设置为行缓冲模式
buffering=0， 设置为无缓冲模式
12、newline参数用来指定读写时，对换行符的处理。
在读文件时，
缺省为 None，表示通用的换行符（“\n”），即文件的换行符是啥，读出来都是 “\n”.
newline = “” 表示读取的换行符保持不变，原来是啥，读出来还是啥。
newline = “\n” 表示遇到 “\n” 才一行结束，“\r” 像其他普通字符一样对待。
newline = “\r” 表示遇到 “\r” 才一行结束，“\n” 像其他普通字符一样对待。
在文件写入时，
newline = None时，写入的“\n” 自动都变为系统默认的换行符。所以 “\r\n” 在windows下会变成“\r\r\n”写入。
newline = “” 表示不做任何转换写入。
newline = “\n” 表示不做任何转换写入。
newline = “\r” 表示将 “\n” 和 “\r” 都当做 “\r” 进行写入，所以“\r\n” 会变成 “\r\r”进行写入。
‘’’

文件操作

1、判断文件是否存在
(1)

try:
    f =open()
    f.close()
except FileNotFoundError:
    print "File is not found."
except PersmissionError:
    print "You don't have permission to access this file."

(2)

import os
os.path.isfile("test-data")

(3)

import pathlib
path = pathlib.Path("path/file")
path.is_file()

2、文件重新命名

import os
os.rename(源文件名, 目标文件名)

3、删除文件

import os
os.remove(文件名)

目录操作

1、创建文件目录

import os
os.mkdir(目录名)

2、查看目录列表

import os
os.listdir(目录名)

3、删除目录

import os
os.rmdir(目录名)

4、获取当前目录

import os
os.getcwd()

5、修改当前目录

import os
os.chdir(目标目录)

6、判断是否为文件目录

import os
os.path.isdir(文件路径)