import sys
sys.path

sys.path.append(‘/home/itcast/xxx‘)
sys.path.insert(0, ‘/home/itcast/xxx‘)    #可以确保先搜索这个路径

In [37]: sys.path.insert(0,"/home/python/xxxx")
In [38]: sys.path
Out[38]: 
[‘/home/python/xxxx‘,
 ‘‘,
 ‘/usr/bin‘,
 ‘/usr/lib/python35.zip‘,
 ‘/usr/lib/python3.5‘,
 ‘/usr/lib/python3.5/plat-x86_64-linux-gnu‘,
 ‘/usr/lib/python3.5/lib-dynload‘,
 ‘/usr/local/lib/python3.5/dist-packages‘,
 ‘/usr/lib/python3/dist-packages‘,
 ‘/usr/lib/python3/dist-packages/IPython/extensions‘,
 ‘/home/python/.ipython‘]

from b import b 

print ‘---------this is module a.py----------‘
def a():
    print("hello, a")
    b() 

a()

from a import a

print ‘----------this is module b.py----------‘
def b():
    print("hello, b")

def c():
    a() 
c()

locals -> enclosing function -> globals -> builtins

def fun1(): a = 10 def fun2(): # a 位于外部嵌套函数的命名空间 print(a)

a = 1
def fun():
  # 需要通过 global 指令来声明全局变量
  global a
  # 修改全局变量，而不是创建一个新的 local 变量
  a = 2

  Python 在启动的时候会自动为我们载入很多内建的函数、类，
  比如 dict，list，type，print，这些都位于 __builtin__ 模块中，
  可以使用 dir(__builtin__) 来查看。
  这也是为什么我们在没有 import任何模块的情况下，
  就能使用这么多丰富的函数和功能了。

  在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后，
  且没有执行程序员所写的任何代码前，Python会首先加载该内建函数到内存。
  另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀，
  其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块
  比如：内建模块中有一个abs()函数，其功能求绝对值，如abs(-20)将返回20。

In [23]: a = [11,22,33]

In [24]: b = [44,55,66]

In [25]: c = (a,b)

In [26]: e = copy.deepcopy(c)

In [27]: a.append(77)

In [28]: a
Out[28]: [11, 22, 33, 77]

In [29]: b
Out[29]: [44, 55, 66]

In [30]: c
Out[30]: ([11, 22, 33, 77], [44, 55, 66])

In [31]: e
Out[31]: ([11, 22, 33], [44, 55, 66])

In [32]: 

In [32]: 

In [32]: f = copy.copy(c)

In [33]: a.append(88)

In [34]: a
Out[34]: [11, 22, 33, 77, 88]

In [35]: b
Out[35]: [44, 55, 66]

In [36]: c
Out[36]: ([11, 22, 33, 77, 88], [44, 55, 66])

In [37]: e
Out[37]: ([11, 22, 33], [44, 55, 66])

In [38]: f
Out[38]: ([11, 22, 33, 77, 88], [44, 55, 66])

In [88]: a = [11,22,33]

In [89]: b = copy.copy(a)

In [90]: id(a)
Out[90]: 59275144

In [91]: id(b)
Out[91]: 59525600

In [92]: a.append(44)

In [93]: a
Out[93]: [11, 22, 33, 44]

In [94]: b
Out[94]: [11, 22, 33]

In [95]:

In [95]:

In [95]: a = (11,22,33)

In [96]: b = copy.copy(a)

In [97]: id(a)
Out[97]: 58890680

In [98]: id(b)
Out[98]: 58890680

    a = "abc"

    b = a[:]

    d = dict(name="zhangsan", age=27)

    co = d.copy()

    a = list(range(10))

    b = list(a)

    十进制数字1 的二进制表现形式: 0000 0000 0000 0001
    十进制数字2 的二进制表现形式: 0000 0000 0000 0010

    对于有符号数，最高位被计算机系统规定为符号位(0为正,1为负)
    对于无符号数，最高位被计算机系统规定为数据位

+2 = 0000 0000 0000 0010
-2 = 1000 0000 0000 0010
真值      机器数

+1 = 0000 0000 0000 0001
-1 = 1000 0000 0000 0001
-----------------------------------------
       1000 0000 0000 0010

规则:
正数：原码 = 反码 = 补码
负数：反码 = 符号位不变，其他位取反
     补码 = 反码+1

1 的原码：0000 0000 0000 0001
-1的原码：1000 0000 0000 0001
-1的反码：1111 1111 1111 1110
-1的补码：1111 1111 1111 1111

1111 1111 1111 1111
0000 0000 0000 0001
---------------------------
0000 0000 0000 0000

原码 = 补码的符号位不变 -->数据位取反--> 尾+1
-1的补码:1111 1111 1111 1111
    取反:1000 0000 0000 0000
-1的原码:1000 0000 0000 0001

#10进制转为2进制
>>> bin(10)
‘0b1010‘

#2进制转为10进制
>>> int("1001",2)
9


#10进制转为16进制
>>> hex(10)
‘0xa‘

#16进制到10进制
>>> int(‘ff‘, 16)
255

>>> int(‘0xab‘, 16)
171

#16进制到2进制
>>> bin(0xa)
‘0b1010‘
>>>

#10进制到8进制
>>> oct(8)
‘010‘


#2进制到16进制
>>> hex(0b1001)
‘0x9‘

各二进位全部左移n位,高位丢弃,低位补0

x << n 左移 x 的所有二进制位向左移动n位,移出位删掉,移进的位补零

各二进位全部右移n位,保持符号位不变

x >> n x的所有二进制位向右移动n位,移出的位删掉,移进的位补符号位 右移不会改变一个数的符号

全1才1否则0 :只有对应的两个二进位均为1时,结果位才为1,否则为0
用6和3这个例子。不要用9 和13的例子

有1就1 只要对应的二个二进位有一个为1时,结果位就为1,否则为0

不同为1 当对应的二进位相异(不相同)时,结果为1,否则为0

#coding=utf-8

class Person(object):
    def __init__(self, name, age, taste):
        self.name = name
        self._age = age 
        self.__taste = taste

    def showperson(self):
        print(self.name)
        print(self._age)
        print(self.__taste)

    def dowork(self):
        self._work()
        self.__away()


    def _work(self):
        print(‘my _work‘)

    def __away(self):
        print(‘my __away‘)

class Student(Person):
    def construction(self, name, age, taste):
        self.name = name
        self._age = age 
        self.__taste = taste

    def showstudent(self):
        print(self.name)
        print(self._age)
        print(self.__taste)

    @staticmethod
    def testbug():
        _Bug.showbug()

#模块内可以访问，当from  cur_module import *时，不导入
class _Bug(object):
    @staticmethod
    def showbug():
        print("showbug")

s1 = Student(‘jack‘, 25, ‘football‘)
s1.showperson()
print(‘*‘*20)

#无法访问__taste,导致报错
#s1.showstudent() 
s1.construction(‘rose‘, 30, ‘basketball‘)
s1.showperson()
print(‘*‘*20)

s1.showstudent()
print(‘*‘*20)

Student.testbug()

class Money(object):
    def __init__(self):
        self.__money = 0

    def getMoney(self):
        return self.__money

    def setMoney(self, value):
        if isinstance(value, int):
            self.__money = value
        else:
            print("error:不是整型数字")

class Money(object):
    def __init__(self):
        self.__money = 0

    def getMoney(self):
        return self.__money

    def setMoney(self, value):
        if isinstance(value, int):
            self.__money = value
        else:
            print("error:不是整型数字")
    money = property(getMoney, setMoney)

In [1]: from get_set import Money

In [2]: 

In [2]: a = Money()

In [3]: 

In [3]: a.money
Out[3]: 0

In [4]: a.money = 100

In [5]: a.money
Out[5]: 100

In [6]: a.getMoney()
Out[6]: 100

class Money(object):
    def __init__(self):
        self.__money = 0

    @property
    def money(self):
        return self.__money

    @money.setter
    def money(self, value):
        if isinstance(value, int):
            self.__money = value
        else:
            print("error:不是整型数字")

In [3]: a = Money()

In [4]: 

In [4]: 

In [4]: a.money
Out[4]: 0

In [5]: a.money = 100

In [6]: a.money
Out[6]: 100

a1 = "HelloWorld"
a2 = "HelloWorld"
a3 = "HelloWorld"
a4 = "HelloWorld"
a5 = "HelloWorld"
a6 = "HelloWorld"
a7 = "HelloWorld"
a8 = "HelloWorld"
a9 = "HelloWorld"

typedef struct_object {
    int ob_refcnt;
    struct_typeobject *ob_type;
} PyObject;

#define Py_INCREF(op)   ((op)->ob_refcnt++) //增加计数
#define Py_DECREF(op) \ //减少计数
    if (--(op)->ob_refcnt != 0)         ;     else         __Py_Dealloc((PyObject *)(op))

list1 = []
list2 = []
list1.append(list2)
list2.append(list1)

import sys
a = "hello world"
sys.getrefcount(a)

import gc

class ClassA():
    def __init__(self):
        print(‘object born,id:%s‘%str(hex(id(self))))

def f2():
    while True:
        c1 = ClassA()
        c2 = ClassA()
        c1.t = c2
        c2.t = c1
        del c1
        del c2

#把python的gc关闭
gc.disable()

f2()

#coding=utf-8
import gc

class ClassA():
    def __init__(self):
        print(‘object born,id:%s‘%str(hex(id(self))))
    # def __del__(self):
    #     print(‘object del,id:%s‘%str(hex(id(self))))

def f3():
    print("-----0------")
    # print(gc.collect())
    c1 = ClassA()
    c2 = ClassA()
    c1.t = c2
    c2.t = c1
    print("-----1------")
    del c1
    del c2
    print("-----2------")
    print(gc.garbage)
    print("-----3------")
    print(gc.collect()) #显式执行垃圾回收
    print("-----4------")
    print(gc.garbage)
    print("-----5------")

if __name__ == ‘__main__‘:
    gc.set_debug(gc.DEBUG_LEAK) #设置gc模块的日志
    f3()

-----0------
object born,id:0x724b20
object born,id:0x724b48
-----1------
-----2------
[]
-----3------
gc: collectable <ClassA instance at 0x724b20>
gc: collectable <ClassA instance at 0x724b48>
gc: collectable <dict 0x723300>
gc: collectable <dict 0x71bf60>
4
-----4------
[<__main__.ClassA instance at 0x724b20>, <__main__.ClassA instance at 0x724b48>, {‘t‘: <__main__.ClassA instance at 0x724b48>}, {‘t‘: <__main__.ClassA instance at 0x724b20>}]
-----5------

print gc.get_count() # (590, 8, 0)
a = ClassA()
print gc.get_count() # (591, 8, 0)
del a
print gc.get_count() # (590, 8, 0)

当计数器从(699,3,0)增加到(700,3,0)，gc模块就会执行gc.collect(0),即检查一代对象的垃圾，并重置计数器为(0,4,0)
当计数器从(699,9,0)增加到(700,9,0)，gc模块就会执行gc.collect(1),即检查一、二代对象的垃圾，并重置计数器为(0,0,1)
当计数器从(699,9,9)增加到(700,9,9)，gc模块就会执行gc.collect(2),即检查一、二、三代对象的垃圾，并重置计数器为(0,0,0)

import gc

class ClassA():
    pass
    # def __del__(self):
    #     print(‘object born,id:%s‘%str(hex(id(self))))

gc.set_debug(gc.DEBUG_LEAK)
a = ClassA()
b = ClassA()

a.next = b
b.prev = a

print "--1--"
print gc.collect()
print "--2--"
del a
print "--3--"
del b
print "--3-1--"
print gc.collect()
print "--4--"

--1--
0
--2--
--3--
--3-1--
gc: collectable <ClassA instance at 0x21248c8>
gc: collectable <ClassA instance at 0x21248f0>
gc: collectable <dict 0x2123030>
gc: collectable <dict 0x2123150>
4
--4--

--1--
0
--2--
--3--
--3-1--
gc: uncollectable <ClassA instance at 0x6269b8>
gc: uncollectable <ClassA instance at 0x6269e0>
gc: uncollectable <dict 0x61bed0>
gc: uncollectable <dict 0x6230c0>
4
--4--

"teachclass.py"

class Person(object):
    pass

#py2中无继承父类，称之经典类,py3中已默认继承object
class Person:
    pass

class Itcast(object):
    def __init__(self,subject1):
        self.subject1 = subject1
        self.subject2 = ‘cpp‘

    #属性访问时拦截器，打log
    def __getattribute__(self,obj):
        if obj == ‘subject1‘:
            print(‘log subject1‘)
            return ‘redirect python‘
        else:   #测试时注释掉这2行，将找不到subject2
            return object.__getattribute__(self,obj)

    def show(self):
        print(‘this is Itcast‘)

s = Itcast("python")
print(s.subject1)
print(s.subject2)

log subject1
redirect python
cpp

  class Person(object):
        def __getattribute__(self,obj):
            print("---test---")
            if obj.startswith("a"):
                return "hahha"
            else:
                return self.test


        def test(self):
            print("heihei")


    t.Person()

    t.a #返回hahha

    t.b #会让程序死掉
        #原因是：当t.b执行时，会调用Person类中定义的__getattribute__方法，但是在这个方法的执行过程中
        #if条件不满足，所以 程序执行else里面的代码，即return self.test  问题就在这，因为return 需要把
        #self.test的值返回，那么首先要获取self.test的值，因为self此时就是t这个对象，所以self.test就是
        #t.test 此时要获取t这个对象的test属性，那么就会跳转到__getattribute__方法去执行，即此时产
        #生了递归调用，由于这个递归过程中 没有判断什么时候推出，所以这个程序会永无休止的运行下去，又因为
        #每次调用函数，就需要保存一些数据，那么随着调用的次数越来越多，最终内存吃光，所以程序 崩溃
        #
        # 注意：以后不要在__getattribute__方法中调用self.xxxx

    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers

a = range(5)
list(a)

In [21]: testList = [x+2 for x in range(5)]

In [22]: testList
Out[22]: [2, 3, 4, 5, 6]

    map(...)
        map(function, sequence[, sequence, ...]) -> list

#函数需要一个参数
map(lambda x: x*x, [1, 2, 3])
#结果为:[1, 4, 9]

#函数需要两个参数
map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])
#结果为:[5, 7, 9]


def f1( x, y ):  
    return (x,y)

l1 = [ 0, 1, 2, 3, 4, 5, 6 ]  
l2 = [ ‘Sun‘, ‘M‘, ‘T‘, ‘W‘, ‘T‘, ‘F‘, ‘S‘ ]
l3 = map( f1, l1, l2 ) 
print(list(l3))
#结果为:[(0, ‘Sun‘), (1, ‘M‘), (2, ‘T‘), (3, ‘W‘), (4, ‘T‘), (5, ‘F‘), (6, ‘S‘)]

filter(...)
    filter(function or None, sequence) -> list, tuple, or string

    Return those items of sequence for which function(item) is true.  If
    function is None, return the items that are true.  If sequence is a tuple
    or string, return the same type, else return a list.

返回值的类型和参数sequence的类型相同

filter(lambda x: x%2, [1, 2, 3, 4])
[1, 3]

filter(None, "she")
‘she‘

reduce(...)
    reduce(function, sequence[, initial]) -> value

    Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the
    sequence is empty.

reduce(lambda x, y: x+y, [1,2,3,4])
10

reduce(lambda x, y: x+y, [1,2,3,4], 5)
15

reduce(lambda x, y: x+y, [‘aa‘, ‘bb‘, ‘cc‘], ‘dd‘)
‘ddaabbcc‘

sorted(...)
    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

>>> x = set(‘abcd‘)
>>> x
{‘c‘, ‘a‘, ‘b‘, ‘d‘}
>>> type(x)
<class ‘set‘>
>>> 
>>> 
>>> y = set([‘h‘,‘e‘,‘l‘,‘l‘,‘o‘])
>>> y
{‘h‘, ‘e‘, ‘o‘, ‘l‘}
>>> 
>>> 
>>> z = set(‘spam‘)
>>> z
{‘s‘, ‘a‘, ‘m‘, ‘p‘}
>>> 
>>> 
>>> y&z #交集
set()
>>> 
>>> 
>>> x&z #交集
{‘a‘}
>>> 
>>> 
>>> x|y #并集
{‘a‘, ‘e‘, ‘d‘, ‘l‘, ‘c‘, ‘h‘, ‘o‘, ‘b‘}
>>> 
>>> x-y #差集
{‘c‘, ‘a‘, ‘b‘, ‘d‘}
>>> 
>>> 
>>> x^z #对称差集(在x或z中，但不会同时出现在二者中)
{‘m‘, ‘d‘, ‘s‘, ‘c‘, ‘b‘, ‘p‘}
>>> 
>>> 
>>> len(x)
4
>>> len(y)
4
>>> len(z)
4
>>>

import functools
dir(functools)

[‘MappingProxyType‘,
 ‘RLock‘,
 ‘WRAPPER_ASSIGNMENTS‘,
 ‘WRAPPER_UPDATES‘,
 ‘WeakKeyDictionary‘,
 ‘_CacheInfo‘,
 ‘_HashedSeq‘,
 ‘__all__‘,
 ‘__builtins__‘,
 ‘__cached__‘,
 ‘__doc__‘,
 ‘__file__‘,
 ‘__loader__‘,
 ‘__name__‘,
 ‘__package__‘,
 ‘__spec__‘,
 ‘_c3_merge‘,
 ‘_c3_mro‘,
 ‘_compose_mro‘,
 ‘_convert‘,
 ‘_find_impl‘,
 ‘_ge_from_gt‘,
 ‘_ge_from_le‘,
 ‘_ge_from_lt‘,
 ‘_gt_from_ge‘,
 ‘_gt_from_le‘,
 ‘_gt_from_lt‘,
 ‘_le_from_ge‘,
 ‘_le_from_gt‘,
 ‘_le_from_lt‘,
 ‘_lru_cache_wrapper‘,
 ‘_lt_from_ge‘,
 ‘_lt_from_gt‘,
 ‘_lt_from_le‘,
 ‘_make_key‘,
 ‘cmp_to_key‘,
 ‘get_cache_token‘,
 ‘lru_cache‘,
 ‘namedtuple‘,
 ‘partial‘,
 ‘partialmethod‘,
 ‘reduce‘,
 ‘singledispatch‘,
 ‘total_ordering‘,
 ‘update_wrapper‘,
 ‘wraps‘]

import functools

def showarg(*args, **kw):
    print(args)
    print(kw)

p1=functools.partial(showarg, 1,2,3)
p1()
p1(4,5,6)
p1(a=‘python‘, b=‘itcast‘)

p2=functools.partial(showarg, a=3,b=‘linux‘)
p2()
p2(1,2)
p2(a=‘python‘, b=‘itcast‘)

def note(func):
    "note function"
    def wrapper():
        "wrapper function"
        print(‘note something‘)
        return func()
    return wrapper

@note
def test():
    "test function"
    print(‘I am test‘)

test()
print(test.__doc__)

note something
I am test
wrapper function

import functools
def note(func):
    "note function"
    @functools.wraps(func)
    def wrapper():
        "wrapper function"
        print(‘note something‘)
        return func()
    return wrapper

@note
def test():
    "test function"
    print(‘I am test‘)

test()
print(test.__doc__)

note something
I am test
test function

import hashlib
m = hashlib.md5()   #创建hash对象，md5:(message-Digest Algorithm 5)消息摘要算法,得出一个128位的密文
print m             #<md5 HASH object>
m.update(‘itcast‘)  #更新哈希对象以字符串参数
print m.hexdigest() #返回十六进制数字字符串

8ad2d682e3529dac50e586fee8dc05c0

http://python.usyiyi.cn/translate/python_352/library/index.html

  python -m SimpleHTTPServer PORT

 python -m http.server PORT

  sudo apt-get install python-setuptools

    sudo easy_install xlrd
    sudo easy_install xlwt

python -m pdb some.py

import pdb
pdb.run(‘testfun(args)‘) #此时会打开pdb调试，注意：先使用s跳转到这个testfun函数中，然后就可以使用l看到代码了

代码上下文
...

import pdb 
pdb.set_trace() 

...

import pdb 
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
final = a + b + c 
print final

#调试方法

# 《1 显示代码》
# l---->能够显示当前调试过程中的代码，其实l表示list列出的意思
  #如下，途中，-> 指向的地方表示要将要执行的位置
  # 2      a = "aaa"
  # 3      pdb.set_trace()
  # 4      b = "bbb"
  # 5      c = "ccc"
  # 6      pdb.set_trace()
  # 7  ->    final = a + b + c
  # 8      print final

# 《2 执行下一行代码》
# n---->能够向下执行一行代码，然后停止运行等待继续调试 n表示next的意思

# 《3 查看变量的值》
# p---->能够查看变量的值，p表示prit打印输出的意思
    #例如：
    # p name 表示查看变量name的值

import pdb 
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
pdb.set_trace()
final = a + b + c 
print final

# 《4 将程序继续运行》
# c----->让程序继续向下执行，与n的区别是n只会执行下面的一行代码，而c会像python xxxx.py一样 继续执行不会停止；c表示continue的意思

# 《5 set_trace()》
# 如果程序中有多个set_trace()，那么能够让程序在使用c的时候停留在下一个set_trace()位置处

#coding=utf-8
import pdb 

def combine(s1,s2):
    s3 = s1 + s2 + s1
    s3 = ‘"‘ + s3 +‘"‘
    return s3

a = "aaa"
pdb.set_trace() 
b = "bbb"
c = "ccc"
final = combine(a,b)
print final

# 《6 设置断点》
# b---->设置断点，即当使用c的时候，c可以在遇到set_trace()的时候停止，也可以在遇到标记有断点的地方停止；b表示break的意思
    #例如：
    #b 11 在第11行设置断点，注意这个11可以使用l来得到
    # (Pdb) l
    #   4          s3 = s1 + s2 + s1
    #   5          s3 = ‘"‘ + s3 +‘"‘
    #   6          return s3
    #   7      a = "aaa"
    #   8      pdb.set_trace()
    #   9  ->    b = "bbb"
    #  10      c = "ccc"
    #  11      final = combine(a,b)
    #  12      print final
    # [EOF]
    # (Pdb) b 11
    # Breakpoint 1 at /Users/wangmingdong/Desktop/test3.py:11
    # (Pdb) c
    # > /Users/wangmingdong/Desktop/test3.py(11)<module>()
    # -> final = combine(a,b)
    # (Pdb) l
    #   6          return s3
    #   7      a = "aaa"
    #   8      pdb.set_trace()
    #   9      b = "bbb"
    #  10      c = "ccc"
    #  11 B->    final = combine(a,b)
    #  12      print final

# 《7 进入函数继续调试》
# s---->进入函数里面继续调试，如果使用n表示把一个函数的调用当做一条语句执行过去，而使用s的话，会进入到这个函数 并且停止
    #例如
    # (Pdb) l
    #   6          return s3
    #   7      a = "aaa"
    #   8      pdb.set_trace()
    #   9      b = "bbb"
    #  10      c = "ccc"
    #  11 B->    final = combine(a,b)
    #  12      print final
    # [EOF]
    # (Pdb) s
    # --Call--
    # > /Users/wangmingdong/Desktop/test3.py(3)combine()
    # -> def combine(s1,s2):
    # (Pdb) l
    #   1      import pdb
    #   2
    #   3  ->    def combine(s1,s2):
    #   4          s3 = s1 + s2 + s1
    #   5          s3 = ‘"‘ + s3 +‘"‘
    #   6          return s3
    #   7      a = "aaa"
    #   8      pdb.set_trace()
    #   9      b = "bbb"
    #  10      c = "ccc"
    #  11 B    final = combine(a,b)
    # (Pdb)

# 《8 查看传递到函数中的变量》
# a---->调用一个函数时，可以查看传递到这个函数中的所有的参数；a表示arg的意思
    #例如：
    # (Pdb) l
    #   1      #coding=utf-8
    #   2      import pdb
    #   3
    #   4  ->    def combine(s1,s2):
    #   5          s3 = s1 + s2 + s1
    #   6          s3 = ‘"‘ + s3 +‘"‘
    #   7          return s3
    #   8
    #   9      a = "aaa"
    #  10      pdb.set_trace()
    #  11      b = "bbb"
    # (Pdb) a
    # s1 = aaa
    # s2 = bbb

# 《9 执行到函数的最后一步》
# r----->如果在函数中不想一步步的调试了，只是想到这个函数的最后一条语句那个位置，比如return语句，那么就可以使用r；r表示return的意思

In [1]: def pdb_test(arg):
   ...:     for i in range(arg):
   ...:         print(i)
   ...:     return arg
   ...:

In [2]: #在python交互模式中，如果想要调试这个函数，那么可以

In [3]: #采用，pdb.run的方式，如下：

In [4]: import pdb

In [5]: pdb.run("pdb_test(10)")
> <string>(1)<module>()
(Pdb) s
--Call--
> <ipython-input-1-ef4d08b8cc81>(1)pdb_test()
-> def pdb_test(arg):
(Pdb) l
  1  ->    def pdb_test(arg):
  2          for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb) l
  1      def pdb_test(arg):
  2  ->        for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(3)pdb_test()
-> print(i)
(Pdb)
0
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb)
> <ipython-input-1-ef4d08b8cc81>(3)pdb_test()
-> print(i)
(Pdb)
1
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb)
demo 5 运行过程中使用pdb修改变量的值
In [7]: pdb.run("pdb_test(1)")
> <string>(1)<module>()
(Pdb) s
--Call--
> <ipython-input-1-ef4d08b8cc81>(1)pdb_test()
-> def pdb_test(arg):
(Pdb) a
arg = 1
(Pdb) l
  1  ->    def pdb_test(arg):
  2          for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) !arg = 100  #!!!这里是修改变量的方法
(Pdb) n
> <ipython-input-1-ef4d08b8cc81>(2)pdb_test()
-> for i in range(arg):
(Pdb) l
  1      def pdb_test(arg):
  2  ->        for i in range(arg):
  3              print(i)
  4          return arg
[EOF]
(Pdb) p arg
100
(Pdb)

#coding=utf-8
import pdb 

def add3Nums(a1,a2,a3):
    result = a1+a2+a3
    return result


def get3NumsAvarage(s1,s2):
    s3 = s1 + s2 + s1
    result = 0
    result = add3Nums(s1,s2,s3)/3

if __name__ == ‘__main__‘:

    a = 11
    # pdb.set_trace() 
    b = 12
    final = get3NumsAvarage(a,b)
    print final

# 不使用垂直对齐时，第一行不能有参数。
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# 参数的缩进和后续内容缩进不能区别。
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

# 悬挂缩进不一定是4个空格
foo = long_function_name(
  var_one, var_two,
  var_three, var_four)
if语句跨行时，两个字符关键字(比如if)加上一个空格，再加上左括号构成了很好的缩进。后续行暂时没有规定，至少有如下三种格式，建议使用第3种。

# 没有额外缩进，不是很好看，个人不推荐.
if (this_is_one_thing and
    that_is_another_thing):
    do_something()

# 添加注释
if (this_is_one_thing and
    that_is_another_thing):
    # Since both conditions are true, we can frobnicate.
    do_something()

# 额外添加缩进,推荐。
# Add some extra indentation on the conditional continuation line.
if (this_is_one_thing
        and that_is_another_thing):
    do_something()

# 右括号不回退，个人不推荐
my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    ‘a‘, ‘b‘, ‘c‘,
    ‘d‘, ‘e‘, ‘f‘,
    )

# 右括号回退
my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    ‘a‘, ‘b‘, ‘c‘,
    ‘d‘, ‘e‘, ‘f‘,
)

import os
import sys
from subprocess import Popen, PIPE

import sys, os

# 括号里边避免空格
# Yes
spam(ham[1], {eggs: 2})
# No
spam( ham[ 1 ], { eggs: 2 } )

# 逗号，冒号，分号之前避免空格
# Yes
if x == 4: print x, y; x, y = y, x
# No
if x == 4 : print x , y ; x , y = y , x

# Yes
ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:]
ham[lower:upper], ham[lower:upper:], ham[lower::step]
ham[lower+offset : upper+offset]
ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]
ham[lower + offset : upper + offset]
# No
ham[lower + offset:upper + offset]
ham[1: 9], ham[1 :9], ham[1:9 :3]
ham[lower : : upper]
ham[ : upper]

# Yes
spam(1)
dct[‘key‘] = lst[index]

# No
spam (1)
dct [‘key‘] = lst [index]

# Yes
x = 1
y = 2
long_variable = 3

# No
x             = 1
y             = 2
long_variable = 3

# Yes
i = i + 1
submitted += 1
x = x*2 - 1
hypot2 = x*x + y*y
c = (a+b) * (a-b)

# No
i=i+1
submitted +=1
x = x * 2 - 1
hypot2 = x * x + y * y
c = (a + b) * (a - b)

 Yes
def complex(real, imag=0.0):
    return magic(r=real, i=imag)

# No
def complex(real, imag = 0.0):
    return magic(r = real, i = imag)

# Yes
if foo == ‘blah‘:
    do_blah_thing()
do_one()
do_two()
do_three()

# No
if foo == ‘blah‘: do_blah_thing()
do_one(); do_two(); do_three()

# No
if foo == ‘blah‘: do_blah_thing()
for x in lst: total += x
while t < 10: t = delay()
更不是：

# No
if foo == ‘blah‘: do_blah_thing()
else: do_non_blah_thing()

try: something()
finally: cleanup()

do_one(); do_two(); do_three(long, argument,
                             list, like, this)

if foo == ‘blah‘: one(); two(); three()