CPython

当我们从Python官方网站下载并安装好Python .6后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。

CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。

CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

PyPy

PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

Jython

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

小结：

　　Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

l1 = [,[,,],,,]

l2 = l1.copy()

l1[].append('')

print(l1,id(l1),id(l1[]))　　　　　　#[, [, , , ''], , ]

print(l2,id(l2),id(l2[]))    　　　 #[, [, , , ''], , ]

############

l1[].append("cao")

print(l1)   #[, [, , , '', 'cao'], , ]

print(l2)　　#[, [, , , '', 'cao'], , ]

#########################

l1[] = "chao"

print(l1)   #['chao', [, , , ''], , ]

print(l2)　　#[, [, , , ''], , ]

import copy

l1 = [,[,,],,,]

l2 = copy.deepcopy(l1)

print(id(l1[]))

print(id(l2[]))

print("="*)

l1[] =

print(l1)

print(l2)

print("="*)

l1[].append('barry')

print(l1)

print(l2)

############

====================

[, [, , ], , ]

[, [, , ], , ]

====================

[, [, , , 'barry'], , ]

[, [, , ], , ]

#魔性的用法:默认参数尽量避免使用可变数据类型

类型一:

lst = []

def func(l = lst):  #默认参数

    l.append()

    print(l)

func()      #[]

func()      #[,]

　　默认参数只会被执行一次：第一次调用函数时，默认参数被初始化为【】，以后每次调用时都会使用已经初始化的【】。

类型二：

lst = []

def func(l = lst):

    l.append()

    print(l)

func([])    #[]

func([])    #[]

类型三：

def func(a1,a2=[]):

    a2.append(a1)

    print(a2)

func() 　　     #[,]

func(,[])      #[,]

func()　　      #[,]

类型四：

def func(a1,a2=[]):

    a2.append(a1)

    return a2

l1 = func()

print(l1)       # [,]

l2 = func(,[])

print(l2)       # [, ]

l3 = func()

print(l3)       # [,]

类型五：

def func(a1,a2=[]):

    a2.append(a1)

    return a2

l1 = func()     # l1=[,]

l2 = func(,[])  # l2=[,]

l3 = func()     # l3=[,]

print(l2)

print(l1)

print(l3)

map()函数接收两个参数，一个是函数，一个是可迭代对象，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

def mul(x):

    return x*x

n=[,,,,]

res=list(map(mul,n))

print(res)  #[, , , , ]

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，

filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

def is_odd(x):

    return x %  == 

v=list(filter(is_odd, [, , , , , , ]))

print(v)  #[, , , ]

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

>>>a = [,,]

>>> b = [,,]

>>> c = [,,,,]

>>> zipped = zip(a,b)     # 打包为元组的列表

[(, ), (, ), (, )]

>>> zip(a,c)              # 元素个数与最短的列表一致

[(, ), (, ), (, )]

>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式

[(, , ), (, , )]

reduce() 函数会对参数序列中元素进行累积。

用传给reduce中的函数 function（有两个参数）先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，最后得到一个结果。

>>>def add(x, y) :            # 两数相加

...     return x + y

...

>>> reduce(add, [,,,,])   # 计算列表和：++++

>>> reduce(lambda x, y: x+y, [,,,,])  # 使用 lambda 匿名函数

class A:

    def send(self):

        print("A")

class B:

    def f(self):

        print("B")

def func(arg):

    arg.send()

obj = A()

func(obj)

多态

　　os.remove(‘path/filename’) 删除文件

　　os.rename(oldname, newname) 重命名文件

　　os.walk() 生成目录树下的所有文件名

　　os.chdir('dirname') 改变目录

　　os.getcwd() 取得当前工作目录

　　os.path.getsize() 返回文件大小

sys.argv           命令行参数List，第一个元素是程序本身路径

sys.exit(n)        退出程序，正常退出时exit(),错误退出sys.exit()

sys.version        获取Python解释程序的版本信息

sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform       返回操作系统平台名称

.     匹配除换行符以外的任意字符

\w    匹配字母或数字或下划线

\s    匹配任意的空白符

\d    匹配数字

\n    匹配一个换行符

\t    匹配一个制表符

\b    匹配一个单词的结尾

^    匹配字符串的开始

$    匹配字符串的结尾

\W

匹配非字母或数字或下划线

\D

匹配非数字

\S

匹配非空白符

a|b

匹配字符a或字符b

()

匹配括号内的表达式，也表示一个组

[...]

匹配字符组中的字符

[^...]

匹配除了字符组中字符的所有字符

用法说明

*    重复零次或更多次

+    重复一次或更多次

?    重复零次或一次

{n}    重复n次

{n,}    重复n次或更多次

{n,m}    重复n到m次

li = [, , , , , , , , , ]

def search(someone, li):

    l = -

    h = len(li)

    while l +  != h:

        m = int((l + h) / )

        if li[m] < someone:

            l = m

        else:

            h = m

    p = h

    if p >= len(li) or li[p] != someone:

        print("元素不存在")

    else:

        str = "元素索引为%d" % p

        print(str)

search(, li)  # 元素索引为2

方法一： 使用os.walk

file-- 是你所要便利的目录的地址, 返回的是一个三元组(root,dirs,files)。

root 所指的是当前正在遍历的这个文件夹的本身的地址

dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)

files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)

def open_2(file):

    for root, dirs , files in os.walk(file):

        print("ss",files)

        for filename in files:

            print(os.path.abspath(os.path.join(root, filename)))   #返回绝对路径

open_2("F:\搜索")

方法二：

import os

def open(files):

    for dir_file in os.listdir(files):

        # print("ss",dir_file)   #递归获取所有文件夹和文件

        files_dir_file = os.path.join(files, dir_file) 

        if os.path.isdir(files_dir_file):  #是不是文件夹

            open(files_dir_file)

        else:

            print(files_dir_file)

open("F:\搜索")

并将下面的所有文件内容写入到一个文件中

def open_2(file):

    for root, dirs , files in os.walk(file):

        for filename in files:

            with open(os.path.abspath(os.path.join(root, filename)), "r") as f:

                for i in f.readlines():

                    print(i)

                    with open("./cao.txt","a",encoding="utf-8") as f2:

                        f2.write(i)

                        f2.write("\n")

open_2("F:\搜索")

try:

    fh = open("testfile", "w")

    try:

        fh.write("这是一个测试文件，用于测试异常!!")

    finally:

        print "关闭文件"

        fh.close()

except IOError:

    print "Error: 没有找到文件或读取文件失败"

raise抛异常

inputValue=input("please input a int data :")

if type(inputValue)!=type():

    raise ValueError

else:

    print inputValue

重写default()

import json

import datetime

dic = {

    'k1':,

    'ctime':datetime.datetime.now()

}

class MyJSONEncoder(json.JSONEncoder):

    def default(self,o):

        if isinstance(o,datetime.datetime):

            return o.strftime("%Y-%m-%d")

        else:

            return super(MyJSONEncoder,self).default(o)

v=json.dumps(dic,cls=MyJSONEncoder)

print(v)

#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。

虽然可以用文件共享数据实现进程间通信，但问题是：

.效率低（共享数据基于文件，而文件是硬盘上的数据）

.需要自己加锁处理

#因此我们最好找寻一种解决方案能够兼顾：、效率高（多个进程共享一块内存的数据）、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。

 队列和管道都是将数据存放于内存中

 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，

我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

from concurrent.futures import ProcessPoolExecutor

import time,os

def piao(name,n):

    print('%s '%(name))

    time.sleep()

    return n**

if __name__=='__main__':

    p = ProcessPoolExecutor()

    objs= []

    for i in range():

        obj = p.submit(piao,'sb %s'%i,i)

        objs.append(obj)

    p.shutdown(wait=True)

    print("主",os.getpid())

    for obj in objs:

        print(obj.result())

from concurrent.futures import ProcessPoolExecutor

import time,os

def piao(name,n):

    print('%s is pioing %s'%(name,os.getpid()))

    return n**

if __name__=='__main__':

    p = ProcessPoolExecutor()

    for i in range():

        res = p.submit(piao,'alex %s'%i,i).result()

        print(res)

    p.shutdown(wait=True)

    print('主',os.getpid())

from concurrent.futures import ThreadPoolExecutor

from threading import current_thread

import time,random

def task(n):

    print('%s is running' %current_thread().getName())

    time.sleep(random.randint(,))

    return n**

if __name__ == '__main__':

    # t=ProcessPoolExecutor() #默认是cpu的核数

    # import os

    # print(os.cpu_count())

    t=ThreadPoolExecutor() #默认是cpu的核数*

    objs=[]

    for i in range():

        obj=t.submit(task,i)

        objs.append(obj)

    t.shutdown(wait=True)

    for obj in objs:

        print(obj.result())

    print('主',current_thread().getName())

            - like '%xx'

                select * from tb1 where name like '%cn';

            - 使用函数

                select * from tb1 where reverse(name) = 'wupeiqi';

            - or

                select * from tb1 where nid =  or email = 'seven@live.com';

                特别的：当or条件中有未建立索引的列才失效，以下会走索引

                        select * from tb1 where nid =  or name = 'seven';

                        select * from tb1 where nid =  or email = 'seven@live.com' and name = 'alex'

            - 类型不一致

                如果列是字符串类型，传入条件是必须用引号引起来，不然...

                select * from tb1 where name = ;

            - !=

                select * from tb1 where name != 'alex'

                特别的：如果是主键，则还是会走索引

                    select * from tb1 where nid !=

            - >

                select * from tb1 where name > 'alex'

                特别的：如果是主键或索引是整数类型，则还是会走索引

                    select * from tb1 where nid >

                    select * from tb1 where num >

            - order by

                select email from tb1 order by name desc;

                当根据索引排序时候，选择的映射如果不是索引，则不走索引

                特别的：如果对主键排序，则还是走索引：

                    select * from tb1 order by nid desc;

一、数学函数

    ROUND(x,y)

        返回参数x的四舍五入的有y位小数的值

    RAND()

        返回０到１内的随机值,可以通过提供一个参数(种子)使RAND()随机数生成器生成一个指定的值。

二、聚合函数(常用于GROUP BY从句的SELECT查询中)

    AVG(col)返回指定列的平均值

    COUNT(col)返回指定列中非NULL值的个数

    MIN(col)返回指定列的最小值

    MAX(col)返回指定列的最大值

    SUM(col)返回指定列的所有值之和

    GROUP_CONCAT(col) 返回由属于一组的列值连接组合而成的结果    

三、字符串函数

    CHAR_LENGTH(str)

        返回值为字符串str 的长度，长度的单位为字符。一个多字节字符算作一个单字符。

    CONCAT(str1,str2,...)

        字符串拼接

        如有任何一个参数为NULL ，则返回值为 NULL。

    CONCAT_WS(separator,str1,str2,...)

        字符串拼接（自定义连接符）

        CONCAT_WS()不会忽略任何空字符串。 (然而会忽略所有的 NULL）。

    CONV(N,from_base,to_base)

        进制转换

        例如：

            SELECT CONV('a',,); 表示将 a 由16进制转换为2进制字符串表示

    FORMAT(X,D)

        将数字X 的格式写为'#,###,###.##',以四舍五入的方式保留小数点后 D 位， 并将结果以字符串的形式返回。若  D 为 , 则返回结果不带有小数点，或不含小数部分。

        例如：

            SELECT FORMAT(12332.1,); 结果为： '12,332.1000'

    INSERT(str,pos,len,newstr)

        在str的指定位置插入字符串

            pos：要替换位置其实位置

            len：替换的长度

            newstr：新字符串

        特别的：

            如果pos超过原字符串长度，则返回原字符串

            如果len超过原字符串长度，则由新字符串完全替换

    INSTR(str,substr)

        返回字符串 str 中子字符串的第一个出现位置。

    LEFT(str,len)

        返回字符串str 从开始的len位置的子序列字符。

    LOWER(str)

        变小写

    UPPER(str)

        变大写

    REVERSE(str)

        返回字符串 str ，顺序和字符顺序相反。

    SUBSTRING(str,pos) , SUBSTRING(str FROM pos) SUBSTRING(str,pos,len) , SUBSTRING(str FROM pos FOR len)

        不带有len 参数的格式从字符串str返回一个子字符串，起始于位置 pos。带有len参数的格式从字符串str返回一个长度同len字符相同的子字符串，起始于位置 pos。 使用 FROM的格式为标准 SQL 语法。也可能对pos使用一个负值。假若这样，则子字符串的位置起始于字符串结尾的pos 字符，而不是字符串的开头位置。在以下格式的函数中可以对pos 使用一个负值。

        mysql> SELECT SUBSTRING('Quadratically',);

            -> 'ratically'

        mysql> SELECT SUBSTRING('foobarbar' FROM );

            -> 'barbar'

        mysql> SELECT SUBSTRING('Quadratically',,);

            -> 'ratica'

        mysql> SELECT SUBSTRING('Sakila', -);

            -> 'ila'

        mysql> SELECT SUBSTRING('Sakila', -, );

            -> 'aki'

        mysql> SELECT SUBSTRING('Sakila' FROM - FOR );

            -> 'ki'

四、日期和时间函数

    CURDATE()或CURRENT_DATE() 返回当前的日期

    CURTIME()或CURRENT_TIME() 返回当前的时间

    DAYOFWEEK(date)   返回date所代表的一星期中的第几天(~)

    DAYOFMONTH(date)  返回date是一个月的第几天(~)

    DAYOFYEAR(date)   返回date是一年的第几天(~)

    DAYNAME(date)   返回date的星期名，如：SELECT DAYNAME(CURRENT_DATE);

    FROM_UNIXTIME(ts,fmt)  根据指定的fmt格式，格式化UNIX时间戳ts

    HOUR(time)   返回time的小时值(~)

    MINUTE(time)   返回time的分钟值(~)

    MONTH(date)   返回date的月份值(~)

    MONTHNAME(date)   返回date的月份名，如：SELECT MONTHNAME(CURRENT_DATE);

    NOW()    返回当前的日期和时间

    QUARTER(date)   返回date在一年中的季度(~)，如SELECT QUARTER(CURRENT_DATE);

    WEEK(date)   返回日期date为一年中第几周(~)

    YEAR(date)   返回日期date的年份(~)

    重点:

    DATE_FORMAT(date,format) 根据format字符串格式化date值

       mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y');

        -> 'Sunday October 2009'

       mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s');

        -> '22:23:00'

       mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00',

        ->                 '%D %y %a %d %m %b %j');

        -> '4th 00 Thu 04 10 Oct 277'

       mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',

        ->                 '%H %k %I %r %T %S %w');

        -> '22 22 10 10:23:00 PM 22:23:00 00 6'

       mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');

        -> '1998 52'

       mysql> SELECT DATE_FORMAT('2006-06-00', '%d');

        -> ''

五、加密函数

    MD5()

        计算字符串str的MD5校验和

    PASSWORD(str)

        返回字符串str的加密版本，这个加密过程是不可逆转的，和UNIX密码加密过程使用不同的算法。

六、控制流函数

    CASE WHEN[test1] THEN [result1]...ELSE [default] END

        如果testN是真，则返回resultN，否则返回default

    CASE [test] WHEN[val1] THEN [result]...ELSE [default]END

        如果test和valN相等，则返回resultN，否则返回default

    IF(test,t,f)

        如果test是真，返回t；否则返回f

    IFNULL(arg1,arg2)

        如果arg1不是空，返回arg1，否则返回arg2

    NULLIF(arg1,arg2)

        如果arg1=arg2返回NULL；否则返回arg1        

七、控制流函数小练习

#7.1、准备表

/*

Navicat MySQL Data Transfer

Source Server         : localhost_3306

Source Server Version : 50720

Source Host           : localhost:3306

Source Database       : student

Target Server Type    : MYSQL

Target Server Version : 50720

File Encoding         : 65001

Date: 2018-01-02 12:05:30

*/

SET FOREIGN_KEY_CHECKS=;

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

-- Table structure for course

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

DROP TABLE IF EXISTS `course`;

CREATE TABLE `course` (

  `c_id` int() NOT NULL,

  `c_name` varchar() DEFAULT NULL,

  `t_id` int() DEFAULT NULL,

  PRIMARY KEY (`c_id`),

  KEY `t_id` (`t_id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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

-- Records of course

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

INSERT INTO `course` VALUES ('', 'python', '');

INSERT INTO `course` VALUES ('', 'java', '');

INSERT INTO `course` VALUES ('', 'linux', '');

INSERT INTO `course` VALUES ('', 'web', '');

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

-- Table structure for score

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

DROP TABLE IF EXISTS `score`;

CREATE TABLE `score` (

  `id` int() NOT NULL AUTO_INCREMENT,

  `s_id` int() DEFAULT NULL,

  `c_id` int() DEFAULT NULL,

  `num` double DEFAULT NULL,

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT= DEFAULT CHARSET=utf8;

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

-- Records of score

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

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '');

INSERT INTO `score` VALUES ('', '', '', '66.7');

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

-- Table structure for student

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

DROP TABLE IF EXISTS `student`;

CREATE TABLE `student` (

  `s_id` varchar() NOT NULL,

  `s_name` varchar() DEFAULT NULL,

  `s_age` int() DEFAULT NULL,

  `s_sex` char() DEFAULT NULL,

  PRIMARY KEY (`s_id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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

-- Records of student

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

INSERT INTO `student` VALUES ('', '鲁班', '', '男');

INSERT INTO `student` VALUES ('', '貂蝉', '', '女');

INSERT INTO `student` VALUES ('', '刘备', '', '男');

INSERT INTO `student` VALUES ('', '关羽', '', '男');

INSERT INTO `student` VALUES ('', '张飞', '', '女');

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

-- Table structure for teacher

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

DROP TABLE IF EXISTS `teacher`;

CREATE TABLE `teacher` (

  `t_id` int() NOT NULL,

  `t_name` varchar() DEFAULT NULL,

  PRIMARY KEY (`t_id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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

-- Records of teacher

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

INSERT INTO `teacher` VALUES ('', '大王');

INSERT INTO `teacher` VALUES ('', 'alex');

INSERT INTO `teacher` VALUES ('', 'egon');

INSERT INTO `teacher` VALUES ('', 'peiqi');

#7.2、统计各科各分数段人数.显示格式:课程ID,课程名称,[-],[-],[-],[ <]

select  score.c_id,

          course.c_name,

      sum(CASE WHEN num BETWEEN  and  THEN  ELSE  END) as '[100-85]',

      sum(CASE WHEN num BETWEEN  and  THEN  ELSE  END) as '[85-70]',

      sum(CASE WHEN num BETWEEN  and  THEN  ELSE  END) as '[70-60]',

      sum(CASE WHEN num <  THEN  ELSE  END) as '[ <60]'

from score,course where score.c_id=course.c_id GROUP BY score.c_id;