Python34-01-Base

##print('Hello World!')

###----数据类型：整数，浮点数，真值，字符串

#a = 10

#print (a)

#print (type(a))

 

###---sequence 序列

#--tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更

##s1 = (2, 1.3, 'love', 5.6, 9, 12, False)         # s1是一个tuple（定值表； 也有翻译为元组）

##s2 = [True, 5, 'smile']                          # s2是一个list(表)

##print (s1),type(s1)

##print (s2),type(s2)

##范围引用： 基本样式[下限:上限:步长]

##print s1[:5]             # 从开始到下标4 （下标5的元素 不包括在内）

#字符串是元组

##str = 'abcdef'

##print str[2:4]

 

 

#运算

##print 1+9        # 加法

##print 1.3-4      # 减法

##print 3*5        # 乘法

##print 4.5/1.5    # 除法

##print 3**2       # 乘方

##print 10%3       # 求余数

 

 

#判断

##print 5==6               # =， 相等

##print 8.0!=8.0           # !=, 不等

##print 3<3, 3<=3          # <, 小于; <=, 小于等于

##print 4>5, 4>=0          # >, 大于; >=, 大于等于

##print 5 in [1,3,5]       # 5是list [1,3,5]的一个元素

 

#逻辑运算

##print True and True, True and False      # and, “与”运算， 两者都为真才是真

##print True or False                      # or, "或"运算， 其中之一为真即为真

##print not True                           # not, “非”运算， 取反

 

#缩进

#if语句

##i = 1

##if i > 0:

##    print 'positive i'

##    i = i + 1

##elif i == 0:

##    print 'i is 0'

##    i = i * 10

##else:

##    print 'negative i'

##    i = i - 1

##

##print ('new i:',i)

 

#for循环

##for a in [3,4.4,'life']:

##    print (a)

##

##idx = range(5)

##print idx #可以看到idx是[0,1,2,3,4]

 

#while循环

 

##while i < 10:

##    print i

##    i = i + 1

 

 

#中断循环

#continue   # 在循环的某一次执行中，如果遇到continue, 那么跳过这一次执行，进行下一次的操作

#break      # 停止执行整个循环

##for i in range(10):

##    if i == 2:        

##        break

##    print i

 

    

####----07

#函数的定义

##def square_sum(a,b):

##    c = a**2 + b**2 # 这一句是函数内部进行的运算

##    return c  # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。

#return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。

#return a,b,c          # 相当于 return (a,b,c)

 

#函数调用和参数传递

#参数传递方式:位置传递、关键字传递、表传递、字典传递

##print square_sum(3,4)

#将一个整数变量传递给函数，函数对它进行操作，但原整数变量a不发生变化

##a = 1

##

##def change_integer(a):

##    a = a + 1

##    return a

##

##print change_integer(a)

##print a

#对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）

#===(Python中 "#" 后面跟的内容是注释，不执行 )

 

##b = [1,2,3]

##

##def change_list(b):

##    b[0] = b[0] + 1

##    return b

##

##print change_list(b)

##print b

#对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 （我们称此为指针传递）

 

 

##dir()用来查询一个类或者对象所有属性

##help()用来查询的说明文档

 

#list类

##print (help(list))

##nl = [1,2,5,3,5]

##print (nl.count(5))       # 计数，看总共有多少个5

##print (nl.index(3))       # 查询 nl 的第一个3的下标

##nl.append(6)            # 在 nl 的最后增添一个新元素6

##nl.sort()               # 对nl的元素排序

##print (nl)

##print (nl.pop())          # 从nl中去除最后一个元素，并将该元素返回。

##nl.remove(2)            # 从nl中去除第一个2

##nl.insert(0,9)          # 在下标为0的位置插入9

#运算符是特殊方法:list的__add__()方法

##print (type([1,2,3]))

print ([1,2,3] + [5,6,9]) 

class superList(list):

    def __sub__(self, b):

        a = self[:]     # 这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。

        b = b[:]        

        while len(b) > 0:

            element_b = b.pop()

            if element_b in a:

                a.remove(element_b)

        return a

 

print (superList([1,2,3]) - superList([3,4]))

 

##词典 (dictionary) 可以储存多个元素。这种储存多个元素的对象称为容器(container)

#基本概念

dic = {'tom':11, 'sam':57,'lily':100}

##print (type(dic))#<class 'dict'>

##与表不同的是，词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。

##print (dic['tom'])

##

##dic['tom'] = 30

##print (dic)

#构建一个新的空的词典

##dic = {}

##print (dic)

 

#增添一个新元素

##dic['lilei'] = 99

##print (dic)

 

#词典元素的循环调用

##dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}

##for key in dic:

##    print (dic[key])

 

    

#词典的常用方法

##print(help(dic))

print (dic.keys())           # 返回dic所有的键

print (dic.values())         # 返回dic所有的值

print (dic.items())          # 返回dic所有的元素（键值对）

del dic['tom']             # 删除 dic 的‘tom’元素

print (dic.keys())           # 返回dic所有的键

print(len(dic))

##dic.clear()                # 清空dic，dict变为{}

 

 

 

 ##上下文管理器--于规定某个对象的使用范围

##语法形式是with...as...

 

 

##关闭文件

##1、普通写法

# without context manager

##f = open("test.txt", "w")

##print(f.closed)               # whether the file is open

##f.write("Hello World!")

##f.close()

##print(f.closed)

 

# 改进  with context manager

##with open("test.txt", "w") as f:

##    print(f.closed)

##    f.write("Hello World!")

##print(f.closed)

##上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进)，上下文管理器自动关闭了文件 (我们通过f.closed来查询文件是否关闭)。我们相当于使用缩进规定了文件对象f的使用范围。

 

##自定义--任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器

# customized object

##class VOW(object):

##    def __init__(self, text):

##        self.text = text

##    def __enter__(self):

##        self.text = "I say: " + self.text    # add prefix

##        return self                          # note: return an object

##    def __exit__(self,exc_type,exc_value,traceback):

##        self.text = self.text + "!"          # add suffix

##

##

##with VOW("I'm fine") as myvow:

##    print(myvow.text)

##

##print(myvow.text)

 

##属性的__dict__系统

 

##对象的属性可能来自于其类定义，叫做类属性(class attribute)

##

##class bird(object):

##    feather = True

##

##class chicken(bird):

##    fly = False

##    def __init__(self, age):

##        self.age = age

##

##summer = chicken(2)

##

##print(bird.__dict__)

##print(chicken.__dict__)

##print(summer.__dict__)

##

##summer.__dict__['age'] = 3

##print(summer.__dict__['age'])

##

##summer.age = 5

##print(summer.age)

 

 

##特性---同一个对象的不同属性之间可能存在依赖关系

##class bird(object):

##    feather = True

##

##class chicken(bird):

##    fly = False

##    def __init__(self, age):

##        self.age = age

##    def getAdult(self):

##        if self.age > 1.0: return True

##        else: return False

##    adult = property(getAdult)   # property is built-in

##

##summer = chicken(2)

##

##print(summer.adult)

##summer.age = 0.5

##print(summer.adult)

##特性使用内置函数property()来创建。property()最多可以加载四个参数。前三个参数为函数，分别用于处理查询特性、修改特性、删除特性。最后一个参数为特性的文档，可以为一个字符串，起说明作用

##

##class num(object):

##    def __init__(self, value):

##        self.value = value

##    def getNeg(self):

##        return -self.value

##    def setNeg(self, value):

##        self.value = -value

##    def delNeg(self):

##        print("value also deleted")

##        del self.value

##    neg = property(getNeg, setNeg, delNeg, "I'm negative")

##

##x = num(1.1)

##print(x.neg)

##x.neg = -22

##print(x.value)

##print(num.neg.__doc__)

##del x.neg

 

##使用特殊方法__getattr__

##class bird(object):

##    feather = True

##

##class chicken(bird):

##    fly = False

##    def __init__(self, age):

##        self.age = age

##    def __getattr__(self, name):

##        if name == 'adult':

##            if self.age > 1.0: return True

##            else: return False

##        else: raise AttributeError(name)

##

##summer = chicken(2)

##

##print(summer.adult)

##summer.age = 0.5

##print(summer.adult)

##

##print(summer.male)

 

##(Python中还有一个__getattribute__特殊方法，用于查询任意属性。__getattr__只能用来查询不在__dict__系统中的属性)

##__setattr__(self, name, value)和__delattr__(self, name)可用于修改和删除属性。它们的应用面更广，可用于任意属性

 

 

##闭包

 

 

 

##装饰器(decorator)--对一个函数、方法或者类进行加工

 

##先定义两个简单的数学函数，一个用来计算平方和，一个用来计算平方差

# get square sum

##def square_sum(a, b):

##    return a**2 + b**2

##

### get square diff

##def square_diff(a, b):

##    return a**2 - b**2

##

##print(square_sum(3, 4))

##print(square_diff(3, 4))

 

##在拥有了基本的数学功能之后，我们可能想为函数增加其它的功能，比如打印输入。我们可以改写函数来实现这一点

# modify: print input

 

# get square sum

##def square_sum(a, b):

##    print("intput:", a, b)

##    return a**2 + b**2

##

### get square diff

##def square_diff(a, b):

##    print("input", a, b)

##    return a**2 - b**2

##

##print(square_sum(3, 4))

##print(square_diff(3, 4))

 

##使用装饰器来实现上述修改：

 

##def decorator(F):

##    def new_F(a, b):

##        print("input", a, b)

##        return F(a, b)

##    return new_F

##

### get square sum

##@decorator

##def square_sum(a, b):

##    return a**2 + b**2

##

### get square diff

##@decorator

##def square_diff(a, b):

##    return a**2 - b**2

##

##print(square_sum(3, 4))

##print(square_diff(3, 4))

 

##装饰器可以用def的形式定义，如上面代码中的decorator。装饰器接收一个可调用对象作为输入参数，并返回一个新的可调用对象。装饰器新建了一个可调用对象，也就是上面的new_F。new_F中，我们增加了打印的功能，并通过调用F(a, b)来实现原有函数的功能

##变量名和对象是分离的。变量名可以指向任意一个对象。从本质上，装饰器起到的就是这样一个重新指向变量名的作用(name binding)，让同一个变量名指向一个新返回的可调用对象，从而达到修改可调用对象的目的

 

 

##含参的装饰器

# a new wrapper layer

def pre_str(pre=''):

    # old decorator

    def decorator(F):

        def new_F(a, b):

            print(pre + "input", a, b)

            return F(a, b)

        return new_F

    return decorator

 

# get square sum

@pre_str('^_^')

def square_sum(a, b):

    return a**2 + b**2

 

# get square diff

@pre_str('T_T')

def square_diff(a, b):

    return a**2 - b**2

 

print(square_sum(3, 4))

print(square_diff(3, 4))

 

##上面的pre_str是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用@pre_str('^_^')调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于

 

 

##装饰类

 

def decorator(aClass):

    class newClass:

        def __init__(self, age):

            self.total_display   = 0

            self.wrapped         = aClass(age)

        def display(self):

            self.total_display += 1

            print("total display", self.total_display)

            self.wrapped.display()

    return newClass

 

@decorator

class Bird:

    def __init__(self, age):

        self.age = age

    def display(self):

        print("My age is",self.age)

 

eagleLord = Bird(5)

for i in range(3):

    eagleLord.display()