Python入门

Python

---

---

列表

列表中添加元素

.append()

列表中删除元素

1.del删除
2..pop()删除列表末尾的元素，删除后还能继续使用
3..remove(' ')根据元素值删除

排序

1.sort永久性排序
2.sorted临时排序

字典

添加字典键-值对

alien_0 = {}alien_0['color'] = 'green'alien_0['points'] = 5

遍历所有的键-值对

for key,value in alien_0.items():    print("Key:" + key)    print("Value:" + value)

遍历所有的键

.keys()

遍历所有的值

.value()

嵌套

1.字典列表

alien_0 = {'color':'green','points':5}alien_1 = {'color':'yellow','points':10}alien_2 = {'color':'red','points':15}aliens = [alien_0, alien_1, alien_2]for alien in aliens:    print(alien)

2.字典中存储列表

favorite_languages = {  'jen' : ['python','ruby'],  'sarah' : ['c'],  'edward' : ['ruby','go'],  'phil' : ['python','haskell'],  }

3.字典中存储字典

users = {    'aeinstein' : {        'first' : 'albert',        'last' : 'einstein',        'location' : 'princeton',        },    'mcurie' : {        'first' : 'marie',        'last' : 'curie',        'location' : 'paris',        },    }

函数的参数

1.默认参数

def enroll(name,gender,age=6,city='Beijing'):    print('name',name)    print('gender',gender)    print('age',age)    print('city',city)

2.可变参数
传入的参数是可变的，任意个。参数前面加一个*号。在参数内部numbers接收到的是一个tuple。但是在函数定义中必须将可变参数放在最后，Python先匹配位置实参和关键字实参。

def calc(*numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum

在list或者tuple前面加一个*号，把list或者tuple的元素变成可变参数传进去

nums = [1,2,3]calc(*nums)

3.关键字参数
可以扩展函数的功能，能接收到更多的参数

def person(name,age,**kw):    print('name:',name,'age:',age,'other:',kw)

>>> person('Bob',35,city='Beijing')name:Bob age:35 other:{'city':'Beijing'}

4.命名关键字参数

#city和job必须显式调用def person(name,age,*,city,job):    print(name,age,city,job)

#city和job必须显式调用>>> person('Jack',24,city='Beijing',job='Engineer')

列表生成式

>>> [x * x for x in range(1,11)]>>> [x * x for x in range(1,11) if x % 2 ==0]>>> [m + n for m in 'ABC' for n in 'XYZ']

迭代器

可直接作用于for循环的对象称为可迭代对象Iterable
包括list,tuple,dict,set,str,generator

可被next()函数调用并不断返回下一个值得对象称为迭代器Iterator
生成器都是Iterator对象

使用iter()函数可以将Iteralbe变成Iterator

函数式编程

高阶函数

1.变量可以指向函数

f = abs>>> f(-10)10

2.一个函数可以接受另一个函数作为参数，这种函数就称之为高阶函数

def add(x,y,f):    return f(x)+f(y)x = -5y = 6f = abs

map/reduce

1.map
map()接收两个参数，一个是函数，一个是Iterable，map()将传入的函数以此作用到序列的每个元素，并把结果作为新的Iterator返回

def f(x):    return x*x>>> r = map(f,[1,2,3,4,5,6,7,8,9])>>> list(r)[1,4,9,16,25,36,49,64,81]

因为Iterator是惰性序列，因此需要通过list()函数来计算并返回一个list

2.reduce
reduce把一个函数作用在一个序列[x1,x2,...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积运算

redece(f,[x1,x2,x3,x4]) = f(f(f(x1,x2),x3),x4)

filter

用于过滤序列，filter()接收一个函数和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素.filter()返回惰性序列，需要用list()获得结果.

def is_odd(n):    return n % 2 == 1list(filter(is_odd,[1,2,4,5,6,9,10,15]))#结果：[1,5,9,15]

#回文数def is_palindrome(n):    return str(n) == str(n)[::-1]list(filter(is_palindrome,range(1000,2000))

sorted

是一个高阶函数，可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序

>>> sorted([36,5,-12,9,-21],key=abs)[5,9,-12,-21,36]

key指定的函数将作用于list的每一个元素上

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def lazy_sum(*args):    def sum():        ax = 0        for n in args:            ax = ax + n        return ax    return sum

返回的函数并没有立刻执行，而是直到调用了f()才执行。返回函数中不要引用任何循环变量，或者后续会发生变化的变量。

匿名函数

lambda 表示匿名函数

lambda x : x * x

装饰器（Decorator）

在代码运行期间动态增加功能的方式。（扩展函数功能，但又不修改原来函数的定义）。其本质是一个返回函数的高阶函数。
把@log放到now()函数的定义处，相当于执行了语句

now = log(now)

import functoolsdef log(func):    @functools.wraps(func)    # *args和**kw是为了保留func函数中的参数    def wrapper(*args,**kw):        #首先打印日志，再紧接着调用原始函数        print('call %s():' % func.__name__)        return func(*args,**kw)    return wrapper

import functoolsdef log(text):    def decorator(func):        @functools.wraps(func)        def wrapper(*arg,**kw):            print('%s %s():' % (text,func.__name__))            return func(*args,**kw)        return wrapper    return decorator

偏函数

functools.partial可以帮助我们创建偏函数，其作用是把一个函数的某些参数给固定住（设置默认值）

def int2(x,base = 2):    return int(x,base)

等价于:

import functoolsint2 = functools.partial(int,base=2)

创建偏函数时，可以接收函数对象、*args和**kw这3个参数

int2 = functools.partial(int,base=2)

实际上固定了int()函数的关键字（kw）base
而当有

max2 = functools.partial(max,10)

实际上会把10作为*args的一部分自动加到左边，也就是：

max2(5,6,7)

相当于

args = (10,5,6,7)max(*args)

结果为10

模块

使用模块

1.导入

import module_namemodule_name.function_name()

或者显式导入

from module_name import function_0, function_1function_0()function_1()

2.as可以给函数或者模块指定别名

from module_name import function_name as fn #函数 import module_name as nm #模块

# -*- coding: utf-8 -*-#此处为文档注释，任何模块代码的第一个字符串都被视为模块他的文档注释' a test module '#此处为作者信息__author__ = 'Kirin'#真正的代码部分import sysdef test():    args = sys.argv    if len(args) == 1:        print('Hello,world!')    elif len(args) == 2:        print('Hello, %s!' % args[1])    else:        print('Too many arguments!')#此处用来运行测试，若直接调用模块本身时，则满足 __name__ == '__main__'if __name__ == '__main__':    test()

作用域
_xxx和__xxx这样的函数或变量是非公开的（private）
外部不需要引用的函数全部定义成private,只有外部需要引用的函数才定义为public

安装第三方模块

python中通过包管理工具pip来安装第三方模块
可以在pypi.python.org网站查询第三方库

面向对象高级编程(类)

数据封装、继承和多态是面向对象程序设计中最基础的3个概念。与Java类似，__name表示的private变量，需要使用get set方法来访问与设置
定义类的方法，第一个参数永远是self，但调用时不需要传入。

class Student(object):    def __init__(self,name.score):        self.name = name        self.name = score    def print_score(self):        print('%s: %s' % (self.name, self.score))

实例和类本身都可以绑定属性和方法，给类本身绑定的属性和方法，其所有实例均可以调用。

def set_score(self,score):    self.score = scoreStudent.set_score = set_score

使用__slots__

限制类和实例的属性，比如只允许对Student实例添加name和age属性。
定义一个特殊的__slots__变量，可以限制该class实例能添加的属性。

class Student(object)    __slots__ = ('name','age) #只能绑定name和age

slots不可继承，父类的限制不会继承给子类。除非在子类中也定义__slots__，这样子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

使用@property

之前需要使用get和set方法来调用属性，并可以在set方法中检查参数。例如：

class Student(object):    def get_score(self):         return self._score    def set_score(self, value):        if not isinstance(value, int):            raise ValueError('score must be an integer!')        if value < 0 or value > 100:            raise ValueError('score must between 0 ~ 100!')        self._score = value

@property负责把一个方法变成属性来调用。

class Student(object):    @property #相当于get方法    def score(self):        return self._score    @score.setter #相当于set方法    def score(self, value):        if not isinstance(value, int):            raise ValueError('score must be an integer!')        if value < 0 or value > 100:            raise ValueError('score must between 0 ~ 100!')        self._score = value

此后可以直接使用s.score（相当于get方法）或s.score = 60（相当于set方法），变成属性调用。
Python内置的@property装饰器就是负责把一个方法变成属性调用的。
把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作。

多重继承

通过多重继承，一个子类就可以同时获得多个父类的所有功能
如果需要“混入”额外的功能，通过多重继承就可以实现。这种设计称为mixIn

class Dog(Animal, Runnalbe, Pet)

定制类

1.__str__&__repr__

2.__iter__

3.__getitem__

4.__getattr__

5.__call__

使用枚举类

from enum import EnumMonth = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

可以直接使用Month.Jan来引用一个常量，或者枚举它的所有成员

for name, member in Month.__members__.items():    print(name, '=>', member, ',', member.value)

如果需要更精确地控制枚举类型，可以从Enum派生出自定义类：

from enum import Enum, unique@uniqueclass Weekday(Enum):    Sun = 0 # Sun的value被设定为0    Mon = 1    Tue = 2    Wed = 3    Thu = 4    Fri = 5    Sat = 6

@unique装饰器可以帮助我们检查保证没有重复值

使用元类

1.type()

错误、调试和测试

错误处理

1.try机制
使用try来运行代码，若执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码except语句块，执行完except后，如果有finally语句块，则必须执行。（也可以没有finally语句）
此外，若没有错误发生，可以在expect语句块后面加一个else，当没有错误发生时，会自动执行else语句。
常见的错误类型
2.记录错误
logging模块
打印错误信息后会继续执行程序，并正常退出。

import loggingdef foo(s):    return 10 / int(s)def bar(s):    return foo(s) * 2def main():    try:        bar('0')    except Exception as e:        logging.exception(e)main()print('END')

3.抛出错误
如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：

class FooError(ValueError):    passdef foo(s):    n = int(s)    if n==0:        raise FooError('invalid value: %s' % s)    return 10 / nfoo('0')

调试

1.断言
凡是用print()来辅助查看的地方，都可以用assert来代替

def foo(s):    n = int(s)    assert n != 0, 'n is zero!'    return 10 / ndef main():    foo('0')

assert的意思是，表达式n != 0应该是True，否则，根据程序运行的逻辑，后面的代码肯定会出错。
若断言失败，assert语句本身会抛出AssertionError
2.logging
loggin不会抛出错误，而且可以输出到文件。可以指定记录信息的级别,有debug,info,warning,error等几个级别。

import logginglogging.basicConfig(level=logging.INFO)#logging配置

3.pdb
python调试器pdb，可以单步调试
4.pdb.set_trace()
首先import pdb，在可能出现错误的地方放一个pdb.set_trace()，相当于设置了一个断点

单元测试

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。
pass

IO编程

异步IO和同步IO

文件读写

with open('/path/to/file', 'r') as f:    print(f.read())

with open('/Users/kirin/test.txt','w') as f:    f.write('Hello,world!')

操作文件和目录

os.path.join(path,x)
os.path.abspath('.')
os.path.split() –> ‘..path’,’file.txt’
os.path.splitext() –> ‘..path’,’.txt’
os.listdir('.')
os.path.isdir()
os.path.isfile()

#搜索当前目录以及所有子目录，查找文件import osdef get_file_path_by_keys(path,keys):    for x in os.listdir(path): #列出目录        x = os.path.join(path,x)        if os.path.isdir(x): #若是子目录则递归            get_file_path_by_keys(x,keys)        elif (os.path.isfile(x) and os.path.splitext(x)[1] == keys): #判断文件类型            print(x)str = input('Enter the file type!\n')get_file_path_by_keys(os.path.abspath('.'),str)

序列化

把变量从内存中变成可存储或传输的过程称之为序列化。
json.dumps()

>>> import json>>> d = dict(name='Bob', age=20, score=88)>>> json.dumps(d)'{"age": 20, "score": 88, "name": "Bob"}'

json.loads()

>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'>>> json.loads(json_str){'age': 20, 'score': 88, 'name': 'Bob'}

要将python中的class实例也转换为JSON对象，必须先将class转换为dict:

print(json.dumps(s, default = lambda obj : obj.__dict__)）

进程和线程

对于操作系统来说，一个任务就是一个进程(Process)，在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，把进程内的这些“子任务”称为线程(Thread)

线程是最小的执行单元，进程由至少一个线程组成。
多任务实现方式：
1.多进程模式
2.多线程模式
3.多进程+多线程模式

多进程(multiprocessing)

pass
Linux下运行

正则表达式

pass
专门看