python面试必问 知识整理

#整型int

　　作用：年纪，等级，身份证号，qq号等整型数字相关

　　定义：

　　　　age=10 #本质age=int(10)

#浮点型float

　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制 

#长整形（了解）

    在python2中（python3中没有长整形的概念）：　　　　　　

    >>> num=2L

    >>> type(num)

    <type 'long'>

#复数（了解）　　

    >>> x=1-2j

    >>> x.real

    1.0

    >>> x.imag

    -2.0　　

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成

name='egon'

#优先掌握的操作：

按索引取值(正向取+反向取) ：只能取

切片(顾头不顾尾，步长)

长度len

成员运算in和not in



移除空白strip

切分split
循环

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔

my_girl_friends=['laoyi','laoer','laosan',4,5] #本质my_girl_friends=list([...])

或

l=list('abc')

#优先掌握的操作：

按索引存取值(正向存取+反向存取)：即可存也可以取

切片(顾头不顾尾，步长)

长度

成员运算in和not in



追加

删除

循环

#ps:反向步长

l=[1,2,3,4,5,6]

#正向步长

l[0:3:1] #[1, 2, 3]

#反向步长

l[2::-1] #[3, 2, 1]

#列表翻转

l[::-1] #[6, 5, 4, 3, 2, 1]

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()

age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

#优先掌握的操作：

按索引取值(正向取+反向取)：只能取

切片(顾头不顾尾，步长)

长度

成员运算in和not in

循环

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型

info={'name':'laoyi','age':18,'sex':'male'} #本质info=dict({....})

或

info=dict(name='laoyi',age=18,sex='male')

或

info=dict([['name','laoyi'],('age',18)])

或

{}.fromkeys(('name','age','sex'),None)

#优先掌握的操作：

按key存取值：可存可取

长度len

成员运算in和not in

删除

键keys()，值values()，键值对items()

循环

#作用：去重，关系运算，

#定义：

            知识点回顾

            可变类型是不可hash类型

            不可变类型是可hash类型

#定义集合:

            集合：可以包含多个元素，用逗号分割，

            集合的元素遵循三个原则：

             1：每个元素必须是不可变类型(可hash，可作为字典的key)

             2:没有重复的元素

             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

#优先掌握的操作：

长度len

成员运算in和not in

|合集

&交集

-差集

^对称差集

==

>，>= ，<,<= 父集，子集           

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

匿名就是没有名字

def func(x,y,z=1):

    return x+y+z

匿名

lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字

func=lambda x,y,z=1:x+y+z

func(1,2,3)

#让其有名字就没有意义

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

#有名函数与匿名函数的对比

有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能

匿名函数：一次性使用，随时随时定义

应用：max，min，sorted,map,reduce,filter

它语法简单，简化代码，不会产生命名冲突，污染命名空间。即用即抛。

#内部函数包含对外部作用域而非全局作用域的引用

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路

        def counter():

            n=0

            def incr():

                nonlocal n

                x=n

                n+=1

                return x

            return incr

        c=counter()

        print(c())

        print(c())

        print(c())

        print(c.__closure__[0].cell_contents) #查看闭包的元素

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

    from urllib.request import urlopen

    def index(url):

        def get():

            return urlopen(url).read()

        return get

    baidu=index('http://www.baidu.com')

    print(baidu().decode('utf-8'))

#开放封闭原则：对修改封闭，对扩展开放

装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。

强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式

装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

import time

def timmer(func):

    def wrapper(*args,**kwargs):

        start_time=time.time()

        res=func(*args,**kwargs)

        stop_time=time.time()

        print('run time is %s' %(stop_time-start_time))

        return res

    return wrapper

@timmer

def foo():

    time.sleep(3)

    print('from foo')

foo()

无参装饰器

def auth(driver='file'):

    def auth2(func):

        def wrapper(*args,**kwargs):

            name=input("user: ")

            pwd=input("pwd: ")

            if driver == 'file':

                if name == 'egon' and pwd == '':

                    print('login successful')

                    res=func(*args,**kwargs)

                    return res

            elif driver == 'ldap':

                print('ldap')

        return wrapper

    return auth2

@auth(driver='file')

def foo(name):

    print(name)

foo('egon')

有参装饰器

被装饰函数的正上方，单独一行

        @deco1

        @deco2

        @deco3

        def foo():

            pass

        foo=deco1(deco2(deco3(foo)))

from functools import wraps

def deco(func):

    @wraps(func) #加在最内层函数正上方

    def wrapper(*args,**kwargs):

        return func(*args,**kwargs)

    return wrapper

@deco

def index():

    '''哈哈哈哈'''

    print('from index')

print(index.__doc__)

#迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: #只是单纯地重复，因而不是迭代

    print('===>') 

l=[1,2,3]

count=0

while count < len(l): #迭代

    print(l[count])

    count+=1

#基于for循环，我们可以完全不再依赖索引去取值了

dic={'a':1,'b':2,'c':3}

for k in dic:

    print(dic[k])

#for循环的工作原理

#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic

#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码

#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

#优点：

  - 提供一种统一的、不依赖于索引的迭代方式

  - 惰性计算，节省内存

#缺点：

  - 无法获取长度（只有在next完毕才知道到底有几个值）

  - 一次性的，只能往后走，不能往前退

#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():

    print('====>first')

    yield 1

    print('====>second')

    yield 2

    print('====>third')

    yield 3

    print('====>end')

g=func()

print(g) #<generator object func at 0x0000000002184360> 

g.__iter__

g.__next__

#2、所以生成器就是迭代器，因此可以这么取值

res=next(g)

print(res)

#1、把列表推导式的[]换成()就是生成器表达式

#2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性

>>> chicken=('鸡蛋%s' %i for i in range(5))

>>> chicken

<generator object <genexpr> at 0x10143f200>

>>> next(chicken)

'鸡蛋0'

>>> list(chicken) #因chicken可迭代，因而可以转成列表

['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4',]

#3、优点：省内存，一次只产生一个值在内存中

排序算法

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。
如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。
通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。

Python内置的sorted()函数就可以对list进行排序：

>>> sorted([36, 5, 12, 9, 21])

[5, 9, 12, 21, 36]

此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个reversed_cmp函数：

def reversed_cmp(x, y):

    if x > y:

        return -1

    if x < y:

        return 1

    return 0

传入自定义的比较函数reversed_cmp，就可以实现倒序排序：

>>> sorted([36, 5, 12, 9, 21], reversed_cmp)

[36, 21, 12, 9, 5]

我们再看一个字符串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])

['Credit', 'Zoo', 'about', 'bob']

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能定义出忽略大小写的比较算法就可以：

def cmp_ignore_case(s1, s2):

    u1 = s1.upper()

    u2 = s2.upper()

    if u1 < u2:

        return -1

    if u1 > u2:

        return 1

    return 0

忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。

这样，我们给sorted传入上述比较函数，即可实现忽略大小写的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

['about', 'bob', 'Credit', 'Zoo']

从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

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

举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

现在，我们用Python代码实现：

>>> 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]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

L = []

for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:

    L.append(f(n))

print(L)

map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

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

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

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

比方说对一个序列求和，就可以用reduce实现：

>>> from functools import reduce

>>> def add(x, y):

...     return x + y

...

>>> reduce(add, [1, 3, 5, 7, 9])

25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

>>> from functools import reduce

>>> def fn(x, y):

...     return x * 10 + y

...

>>> reduce(fn, [1, 3, 5, 7, 9])

13579

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> from functools import reduce

>>> def fn(x, y):

...     return x * 10 + y

...

>>> def char2num(s):

...     return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

...

>>> reduce(fn, map(char2num, ''))

13579

整理成一个str2int的函数就是：

from functools import reduce

def str2int(s):

    def fn(x, y):

        return x * 10 + y

    def char2num(s):

        return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

from functools import reduce

def char2num(s):

    return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

def str2int(s):

    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

#1、示例

egg_list=[]

for i in range(10):

    egg_list.append('鸡蛋%s' %i)

egg_list=['鸡蛋%s' %i for i in range(10)]

#2、语法

[expression for item1 in iterable1 if condition1

for item2 in iterable2 if condition2

...

for itemN in iterableN if conditionN

]

类似于

res=[]

for item1 in iterable1:

    if condition1:

        for item2 in iterable2:

            if condition2

                ...

                for itemN in iterableN:

                    if conditionN:

                        res.append(expression)

#3、优点：方便，改变了编程习惯，可称之为声明式编程

其一, 在不加括号时候, and优先级大于or
其二, x or y 的值只可能是x或y.  x为真就是x, x为假就是y
第三, x and y 的值只可能是x或y.  x为真就是y, x为假就是x
显然,对于, 1 or 5 and 4: 先算5 and 4, 5为真, 值为4. 再算1 or 4, 1 为真,值为1
对于, (1 or 5) and 4: 先算1 or 5, 1为真, 值为1. 再算1 and 4, 1为真,值为4

求值技巧

关于求值的顺序，先左部，再右部，还要加入“短路”机制，说明这点的文档原文： 
对应同一优先级，我个人的理解为：or的目的是找到作用范围内第一个True或最后一个False，and的目的是找到作用范围第一个False或最后一个True。（其中，作用范围内的概念必须明确）。
#对于and而言，第一行返回（作用范围内）第一个假值，第二行返回最后一个正值
#对于or而言，第一行返回（作用范围内）第一个真值，第二行返回最后一个假值

GIL锁

GIL锁并不是PYTHON的特性，是在实现cpython解释器的时候引入的一个概念，

python完全可以不依赖GIL

一个防止   多线程并发执行机器码的一个互斥锁

为什么会有GIL锁

由于物理上的限制，cpu厂商在核心频率上的比赛被多核取代，为了更有效的利用多喝处理器的性能，

就出现了多线程的编程方式，随之带来的问题就是线程间数据一致性和状态同步的困难

即使在cpu内部的缓存也不例外，

python当然也逃不开，为了利用多核，python开始支持多线程。而解决多线程之间数据完整性和状态同步的最简单方法就是枷锁。

所以就有了GIL这把超级大锁，而当越来越多代码库开发者，接收了这种设定之后，开始大量依赖这样特性（即默认线程安全）

可是慢慢的这种方式被发现是蛋疼而且低效的，当大家视图去拆分和去除GIL的时候，发现大量库的开发组已经中毒依赖GIL而且很难去除了

总结：

因为GIL的存在，只有IO密集型的场景下，多线程会得到较好的性能

如果对计算性能较高的程序可以考虑把核心部分换成或者用其他语言实现

os就是一个普通的python库，用来向Python程序提供运行环境，特别是在文件系统、创建新进程、获取操作系统本身的一些信息（比如uname)，并屏蔽各种不同操作系统之间的细节差异。

sys模块则是python程序用来请求解释器行为的接口。
比如关于调试类的（trace, frames，except）等，profiling类（stats， getsizeof)，运行时环境类（python path, stderr, stdout)，解释器本身（如version）
。inspect某种程度上可以看成是在sys提供的功能上的一个包装。

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.curdir  返回当前目录: ('.')

os.pardir  获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2')    可生成多层递归目录

os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove()  删除一个文件

os.rename("oldname","newname")  重命名文件/目录

os.stat('path/filename')  获取文件/目录信息

os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command")  运行shell命令，直接显示

os.environ  获取系统环境变量

os.path.abspath(path)  返回path规范化的绝对路径

os.path.split(path)  将path分割成目录和文件名二元组返回

os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)  如果path是绝对路径，返回True

os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

os路径处理

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    os.pardir, #上一级

    os.pardir,

    os.pardir

))

sys.path.insert(0,possible_topdir)

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

 sys.exit(n)        退出程序，正常退出时exit(0)

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

 sys.maxint         最大的Int值

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

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

    时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

    格式化的时间字符串(Format String)

    结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

 import time

 #--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间

 print(time.time()) # 时间戳:1487130156.419527

 print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'

 print(time.localtime()) #本地时区的struct_time

 print(time.gmtime())    #UTC时区的struct_time    结构化时间

  #--------------------------按图1转换时间

  # localtime([secs])

  # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

  time.localtime()

  time.localtime(1473525444.037215)

  # gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

  # mktime(t) : 将一个struct_time转化为时间戳。

  print(time.mktime(time.localtime()))#1473525749.0

 # strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和

 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个

 # 元素越界，ValueError的错误将会被抛出。

  print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

 # time.strptime(string[, format])

 # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

  print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

 #  tm_wday=3, tm_yday=125, tm_isdst=-1)

 #在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

1 #--------------------------按图2转换时间

2 # asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

3 # 如果没有参数，将会将time.localtime()作为参数传入。

4 print(time.asctime())#Sun Sep 11 00:43:43 2016

5

6 # ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为

7 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

8 print(time.ctime())  # Sun Sep 11 00:46:38 2016

9 print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

1 #--------------------------其他用法

2 # sleep(secs)

3 # 线程推迟指定的时间运行，单位为秒。

#时间加减

import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925

#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19

# print(datetime.datetime.now() )

# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天

# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天

# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时

# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

#

# c_time  = datetime.datetime.now()

# print(c_time.replace(minute=3,hour=2)) #时间替换

class Kls(object):

    def __init__(self, data):

        self.data = data

    def printd(self):

        print(self.data)

ik1 = Kls('arun')

ik2 = Kls('seema')

ik1.printd()

ik2.printd()
得到的输出:

1/2 参数传递给函数

3   self参数指向实例本身

4   我们不需要显式提供实例，解释器本身会处理

def get_no_of_instances(cls_obj):

    return cls_obj.no_inst

class Kls(object):

    no_inst = 0

    def __init__(self):

        Kls.no_inst = Kls.no_inst + 1

ik1 = Kls()

ik2 = Kls()

print(get_no_of_instances(Kls))

2

def iget_no_of_instance(ins_obj):

    return ins_obj.__class__.no_inst

class Kls(object):

    no_inst = 0

    def __init__(self):

        Kls.no_inst = Kls.no_inst + 1

ik1 = Kls()

ik2 = Kls()

print iget_no_of_instance(ik1)

结果

2

class Kls(object):

    no_inst = 0

    def __init__(self):

        Kls.no_inst = Kls.no_inst + 1

    @classmethod

    def get_no_of_instance(cls_obj):

        return cls_obj.no_inst

ik1 = Kls()

ik2 = Kls()

print ik1.get_no_of_instance()

print Kls.get_no_of_instance()

2
2

IND = 'ON'

def checkind():

    return (IND == 'ON')

class Kls(object):

    def __init__(self,data):

        self.data = data

    def do_reset(self):

        if checkind():

            print('Reset done for:', self.data)

    def set_db(self):

        if checkind():

            self.db = 'new db connection'

            print('DB connection made for:',self.data)

ik1 = Kls(12)

ik1.do_reset()

ik1.set_db()

IND = 'ON'

class Kls(object):

    def __init__(self, data):

        self.data = data

    @staticmethod

    def checkind():

        return (IND == 'ON')

    def do_reset(self):

        if self.checkind():

            print('Reset done for:', self.data)

    def set_db(self):

        if self.checkind():

            self.db = 'New db connection'

        print('DB connection made for: ', self.data)

ik1 = Kls(12)

ik1.do_reset()

ik1.set_db()

class Kls(object):

    def __init__(self, data):

        self.data = data

    def printd(self):

        print(self.data)

    @staticmethod

    def smethod(*arg):

        print('Static:', arg)

    @classmethod

    def cmethod(*arg):

        print('Class:', arg)

>>> ik = Kls(23)

>>> ik.printd()

23

>>> ik.smethod()

Static: ()

>>> ik.cmethod()

Class: (,)

>>> Kls.printd()

TypeError: unbound method printd() must be called with Kls instance as first argument (got nothing instead)

>>> Kls.smethod()

Static: ()

>>> Kls.cmethod()

Class: (,)

1. 由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户。
这个机制就是Session.
典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户。
这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识。     
在服务端保存Session的方法很多，内存、数据库、文件都有。
集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放 Session。

2. 思考一下服务端如何识别特定的客户？
这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。
实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，
以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。
有人问，如果客户端的浏览器禁用了 Cookie 怎么办？
一般这种情况下，会使用一种叫做URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。

3. Cookie其实还可以用在一些方便用户的场景下，设想你某次登陆过一个网站，下次登录的时候不想再次输入账号了，怎么办？
这个信息可以写到Cookie里面，访问网站的时候，网站页面的脚本可以读取这个信息，就自动帮你把用户名给填了，能够方便一下用户。
这也是Cookie名称的由来，给用户的一点甜头。

所以，总结一下：
Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中；
Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。