Python基本知识

安装Python之后有python解释器、命令行交互环境、简单的集成开发环境
python交互环境下执行代码会自动打印结果，而.py文档必须用print()函数打印
注释用#符号
缩进决定结构
路径用\分隔，如F:\xxx

输入输出

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格
input()返回输入的值，其参数可以作为提示信息输出
输出多行：

print('''可以
输入多行
字符串
代替
字符''')

格式化输出：

print('haha%dhah%s' % (55,'string'))

r'内部字符不转义'，也就是按照引号内部的原本内容输出，取消转义字符的意义

数据类型及运算符

python是动态语言，本身类型不固定，弱化数据类型，变量可以被赋给任意值
类型转换：int('6') 将字符6转换成数字6，如果字符并非数字，则报错
布尔运算符： and or not
10/3结果为浮点数，10//3为整数，10//3.0强制取整数部分，但小数点后有一位0

字符串及编码

python 中字符串采用unicode编码，内存中以字符为单位的str，保存到磁盘上需要用以字节为单位的bytes
用encode()函数可以将str转化成bytes，如：'中文'.encode('utf-8') = b'xe4xb8xadxe6x96x87'
用decode()函数可以将bytes转化成str，如：b'abc'.decode('ascii') = 'abc'
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
len()函数，len('abc') = 3，len('中文'.encode('utf-8')) = 6

序列

list列表

l = ['a','b','c']
l.append('e')
l.insert(3,'d')
l.pop(0)

list各元素可不同类型，也可以是list；l = ['x',y,z]；

增：append('element')--追加到末尾、insert(x , 'element')--指定索引号插入、
删：pop(x)--删除元素；
改：有序集合，按标号更改；
查：可正负索引查内容，负标号表示倒数第几个，len()查长度

tuple元组

有序集合，初始化后固定不可改，但内嵌list的值可以更改；tuplename = ('x','y','z')；可正负索引；
定义只有一个元素的tuple：t = (1 , )消除歧义

dict词典

d = {'a':1, 'b':2, 'c':3}
d['d'] = 4
d.pop('d')
d.get('d',-1)
for key in d:
for value in d.values():
for k,v in d.items():

词典，存储键值对的集合；d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
检测Key是否存在： 'Bob' in d （判断为true 或 false）或者 d.get('Bob',-1) 不存在时返回-1
d.pop(key)方法删除相应的值
key只能是不可变的对象

set集合

s = set(list(range(1,5)))
s.add(5)
s.remove(5)
st = set([3,4,5,6])
s & st
s | st

不含重复元素的集合，只保存key值
s = set([a,b,c,d]) 创建时只能用set()方法和一个list
s.add(key) 和 s.remove(key)

高级特性

切片

对list, tuple, string 进行截取操作
如 num = [1,2,3,4,5,6,7]，num[0:6:2]的值等于[1,3,5]（从索引0到索引6-1，每2个数取一次）
(1,2,3,4,5,6)[0:3]等于(1,2,3)
'tofengz'[0:2]等于'to'

列表生成式

按格式生成list的快捷方式

[x*y for x in a for y in b]

对变量的操作或运算放在前面，后面用for或者if语句注明前面变量的条件或范围，前例为双重循环

生成器

将列表生成器的[ ]改为（）之后，就定义了一个list的规则，
并不直接存储列表的值，只是当用next()函数或者for迭代取list的值时，根据规则生成相应的值。
也可以通过函数式定义generator，将函数中输出计算结果的地方改为 yield x 语句，即可将函数改造为生成器，例如：

def  fun(x):
    n = 0
    while n < x:
        y = x*x
        yield y
    return 'finish'

可以通过next()取值或者for x in fun(m) 迭代取值（生成器是可迭代对象），但迭代无法得到return内容，因为不能捕获异常

可迭代对象

只要是可迭代对象都可以用for in

for x in 'abcd'
for x, y in dict.item()
for y in dict.value()

迭代器

可以迭代的对象称为可迭代对象Iterable ，而可以用next()不断取值的称为迭代器Iterator，
list, tuple等是Iterable但不是Iterator，所有生成器是Iterator对象
迭代器Iterator是惰性计算，不能预知长度，可以无限长

流程控制

条件判断

if x > 1 :
elif x < 0 :
elif ... :
else :

循环

for x in list['c','b','a']: --依次取出list中的所有元素，注意后面有冒号
while xxxx :
可用break和continue
ps: range(5)可以生成0~4的整数序列，list(range(5)) = [0,1,2,3,4]

函数

定义

def xxx(var):
    …
    return x,y

可以返回多个值(tuple类型)

x ＝ xxx(a)    #x ＝ (x,y)
x,y ＝ xxx(a)  #x ＝ x,  y ＝ y

表示某一步什么都不做时，用pass语句占位
可以把函数的定义单独放在一个文件里，每次调用前注明 from base import xxx
函数是一种对象，有内置参数fun.name（两个下划线）

参数

必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

function(x, y = 2, *z, a, **p)

x——必选参数
y—— 默认参数(未传递数值时设定的一个缺省值)
z ——可变参数(接受零个、一个或多个参数，保存为tuple。而当一个list, tuple对象传入时，要在变量名之前加上*，将其视为可变参数)
p ——关键词参数(以t = i的格式传入，保存为dict--{'t':'i'}。当一个dict对象传入时，变量名之前加上**会将内容保存到新dict中)
a—— 命名关键词参数(在分隔符 ,之后或者可变参数（已经包含一个）之后，传入时必须指明定义时的参数名，如a = 'dd'的格式，直接'dd'报错)，来要求输入指定的关键词参数

高阶函数

把函数作为参数传入函数

map(f,x)
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
reduce(f(a1,a2),x)
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
filter(f,x)
filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True/False决定保留/丢弃该元素
sorted(x,f)
将x序列经过f函数处理后再排序

返回函数

返回值为函数的函数（函数生成器）
返回的函数并未执行，而是等到调用时才执行
返回的函数可以引用原函数的参数，但不要去引用变化的参数

f = makef()  #得到返回的函数，但未被调用
f()

匿名函数

用lambda定义一个函数，不指定函数名；只能有一个语句；可以没有返回值；可以赋给变量

lambda x:x*x

可用于高阶函数的参数

装饰器

以函数为参数，对函数进行“装饰”（增加功能）的函数

import functools
def decorator(func):
	@functools.wraps(func)
	def wrapper(*args,**kw):
        	print('....')
		...
		return func(*args,**kw)
	return wrapper

@decorator
def afunc():
	...		#相当于 ——> afunc = decorator(afunc)

如此定义后，afunc指向了新的函数，即wrapper()，以此为函数增加功能

偏函数

import functools
newfunc = funtools.partial(sfunc,args)

相当于固定了sfunc()的args参数后生成了简介专用版新函数newfunc()
functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
当函数的参数个数太多需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

模块

在Python中，一个.py文件就称之为一个模块（Module），相同名字的函数和变量完全可以分别存在不同的模块中
为了避免模块名冲突，又引入了按目录来组织模块的方法，称为包（Package），每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。init.py可以是空文件，也可以有Python代码。
可以形成多层目录
模块的格式：

# !/usr/bin/env python3
# -*- coding: utf-8 -*-
'这里写文档注释'
__author__ = '作者'

import sys
def test():
	args = sys.argv     		#该变量获取命令行参数
	if len(args) == 1:
		print('hello')
	elif len(args) == 2:
		print('hello,%s' %args[1])
	else:
		print('too many arguments')

if __name__ == '__main__':		#命令行下运行此模块时才会执行下一句
	test()						#其他地方导入时不会自动执行

模块中正常的函数和变量名是公开的，可以被直接引用，如abc
类似__xxx__这样的也可以被直接引用，但是有特殊用途，自己不要这样命名
类似_xxx , __xxx这样的函数或变量就是非公开的，不应该被直接引用
在实际编程时，模块内函数的主体结构可以定义为public，但是内部逻辑可以封装为private
使用pip工具可以方便的安装第三方模块，如：pip install Pillow

面向对象编程

定义类

（类名一般大写字母开头）

class Student(object):

	#采用此方法把一些认为必须绑定的属性强制填写进去
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def xxx(self,m):
    	...

#定义的类要实例化之后再使用
li = Student('lining',98)
li.xxx(n)

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。
要定义一个方法，除了第一个参数是self外，其他和普通函数一样。
要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入
使用“__xx”定义方式将类中的属性私有化。
- 防止外部直接访问属性变量
- 通过类的方法对属性进行操作，可以检查传入的参数

继承和多态

子类可以继承父类的全部方法
子类中可以覆写父类的方法（原来的方法被覆盖）
任何接受父类为参数的函数或方法，都可以接受其子类作为参数。而在方法内部按照父类的类型进行操作即可。（多态）
Python这样的动态语言来说，则不一定需要传入父类或者其子类。只需要保证传入的对象有相应的方法就可以了。（鸭子类型）

查阅对象信息（在不知道对象是否有此属性时才使用）

type(x)----返回对应的Class类型
isinstance(x,class)----判断一个对象是否是某种类型
dir(x)----查看一个对象的所有属性和方法
getattr(obj,'attr')、setattr(obj,'attr',value)、hasattr(obj,'attr')
通过内置的一系列函数，我们可以对任意一个Python对象进行剖析，拿到其内部的数据。要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。
如果要获得一个对象的所有属性和方法，可以使用dir()函数，配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态
总是优先使用isinstance()判断类型，可以将指定类型及其子类“一网打尽”。

其它

在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性
给一个实例绑定的方法，对另一个实例是不起作用的，为了给所有实例都绑定方法，可以给class绑定方法。
动态绑定允许我们在程序运行的过程中动态给class加上功能
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性。但仅对当前类实例起作用，对继承的子类是不起作用的。