Python小复习

#usr/bin/python
#-*-coding:utf-8-*-
ss='''
a,b=3,4
c=a+b
print(c)
'''
print(ss)#执行存储在字符串中的Python代码
exec(ss)#exec语句不会返回任何对象。而eval会返回表达式的值
print('----------------------------------------------------------------------')
date=[i for i in range(1,21)]
print(date)
#list 分片处理 list[开始:结束:步长] list[开始:结束]=list
print(date[14:8:-1])
date[7:12]=99,999,9999
print(date)
print('----------------------------------------------------------------------')
d1={1,2,3,4,5,6,7}
d2={2,4,7,8,-2}
print(d1^d2)
# & | - ^ 交 并 差 对称差集
print('----------------------------------------------------------------------')
kv={'en':'勒戒','cn':'快乐'}
print(kv.values())
print(kv.keys())
print(kv.items())
print(kv.get('cn-00','无此说法'))
print('----------------------------------------------------------------------')
# f=lambda x,y,z:str(x)+str(y)+str(z)
def f(x,y,z):
    key=x
    v=(y,z)
    return {key:v}
d=('a','b','c')
z=(4,3,7)
m=('M','N','H')
# rs=zip(f,d,z)
rs=map(f,d,z,m)
print(list(rs))
print('----------------------------------------------------------------------')
#函数 独立定义和调用
#方法 依赖定义和调用
def h():
    print('函数')
class A:
    def h(self):
        print('方法')
h()
# A().h()
a=A()
print(id(a))
a.h()
print('----------------------------------------------------------------------')
#变量的作用域 内置 全局 嵌套 局部
def a():
    print('aaaa')
    def b():
        print('bbb')
    return b
a()()
print('----------------------------------------------------------------------')
#面向对象
class BTree:
    root=None
    class Node:
        data=None
        left=None
        right=None
        def zhongxu(self):
            if self.left is not None:
                self.left.zhongxu()
            print(self.data)
            if self.right is not None:
                self.right.zhongxu()
        def add(self,node):
            if self.data>node.data:
                if self.left is None:
                    self.left=node
                else:
                    self.left.add(node)
            if self.data<node.data:
                if self.right is None:
                    self.right=node
                else:
                    self.right.add(node)
    def add(self, data):
        node=self.Node()
        node.data=data
        if self.root is None:
            self.root=node
        else:
            self.root.add(node)
    def zhongxu(self):
        self.root.zhongxu()
if __name__=='__main__':
    btree=BTree()
    btree.add(123)
    btree.add(12.3)
    btree.add(1.23)
    btree.add(0.123)
    btree.add(0.0123)
    btree.add(0.00123)
    btree.add(0.000123)
    btree.zhongxu()
print('----------------------------------------------------------------------')
if __name__=='__main__':
    xiaohai=[i for i in range(1,11)]
    count=0
    while True:
        if len(xiaohai)==1:
            break
        count+=1
        if count%3==0:
            xiaohai.pop(0)
        else:
            xiaohai.append(xiaohai.pop(0))
    print(xiaohai)
print('----------------------------------------------------------------------')

'''
   根据当前节点获取父节点
   根据当前节点获取所有子节点
   根据当前节点获取所有祖先节点
   根据当前节点获取所有子孙节点
   根据当前节点获取所有兄弟节点
   js javascript
   {
   var n=10
   var m=10;
   function foo(a,b)
       return a+b
    }
'''
class Tree:
    childToParent=None
    parentToChildren=None
    def add(self,parent,child):
        if self.childToParent is None:
            self.childToParent={child:parent}
        else:
            self.childToParent[child]=parent
        if self.parentToChildren is None:
            self.parentToChildren={parent:[]}
        children=self.parentToChildren.get(parent,[])
        if len(children)==0:
            self.parentToChildren[parent]=children
        children.append(child)
    def getParent(self,child):
        return self.childToParent.get(child,'没有父亲的节点')
    def getChildren(self,parent):
        return self.parentToChildren.get(parent,'没下级')
    def getZuXian(self,zisun):
        '''
        思想就是递归问爹
        1.获取上一级getParent
        2.让上一级返回的数据执行 getParent 一次执行直到没有上一级 终止
        :param zisun:
        :return:
        '''
        parent=self.getParent(zisun)
        if parent is None:
            return []
        zupu=self.getZuXian(parent)
        zupu.append(parent)
        return zupu
    def zisun(self,zs,zu):
        '''
        1. 得到当前节点的孩子
        2.遍历当前节点的孩子,每一个孩子得到他们的孩子
        :param zs:
        :param zu:
        :return:
        '''
        children=self.getChildren(zu)
        if children == '没下级':
            return
        for c in children:
            self.zisun(zs,c)
        zs.extend(children)
    def getSibiling(self,s):
        parent=self.getParent(s)
        children=self.getChildren(parent)
        children.remove(s)
        return children





if __name__=='__main__':
    tree=Tree()
    tree.add(None,'学校')
    tree.add('学校','商学院')
    tree.add('学校','法学院')
    tree.add('学校','电子学院')
    tree.add('学校','外语学院')
    tree.add('学校','计算机学院')
    tree.add('计算机学院','软件')
    tree.add('计算机学院','网络')
    tree.add('计算机学院','数据')
    tree.add('网络','网一')
    tree.add('网络','网二')
    tree.add('网络','网三')

    child='网三'
    parent=tree.getParent(child)
    print('{1}的上级是:{0}'.format(parent,child))

    parent = "计算机学院"
    children = tree.getChildren(parent)
    print("{0}的子级是:{1}".format(parent,children))

    zisun='网三'
    zuxian=tree.getZuXian(zisun)
    print('{0}的祖先是{1}'.format(zisun,zuxian))

    zu='学校'
    zs=[]
    tree.zisun(zs,zu)
    print('{0}的子孙是{1}'.format(zu, zs))

    sibling='法学院'
    rs=tree.getSibiling(sibling)
    print('{0}的兄弟是{1}'.format(sibling,rs))

a,b=3,4
c=a+b
print(c)


7
----------------------------------------------------------------------
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[15, 14, 13, 12, 11, 10]
[1, 2, 3, 4, 5, 6, 7, 99, 999, 9999, 13, 14, 15, 16, 17, 18, 19, 20]
----------------------------------------------------------------------
{1, 3, 5, 6, 8, -2}
----------------------------------------------------------------------
dict_values(['勒戒', '快乐'])
dict_keys(['en', 'cn'])
dict_items([('en', '勒戒'), ('cn', '快乐')])
无此说法
----------------------------------------------------------------------
[{'a': (4, 'M')}, {'b': (3, 'N')}, {'c': (7, 'H')}]
----------------------------------------------------------------------
函数
42020048
方法
----------------------------------------------------------------------
aaaa
bbb
----------------------------------------------------------------------
0.000123
0.00123
0.0123
0.123
1.23
12.3
123
----------------------------------------------------------------------
[4]
----------------------------------------------------------------------
网三的上级是:网络
计算机学院的子级是:['软件', '网络', '数据']
网三的祖先是['学校', '计算机学院', '网络']
学校的子孙是['网一', '网二', '网三', '软件', '网络', '数据', '商学院', '法学院', '电子学院', '外语学院', '计算机学院']
法学院的兄弟是['商学院', '电子学院', '外语学院', '计算机学院']


进程已结束,退出代码0