2018.07.18

#获取昨天的日期
from datetime import datetime,timedelta

yesterday=datetime.now()-timedelta(days=1)
layout=yesterday.strftime('%Y-%m-%d')
print(layout)


#*args,**kwargs的区别和应用场景
'''
包裹位置传递--*args:args是一个元组（tupple），会存放所有未命名的变量参数
包裹关键字传递--**kwargs:kwargs是一个字典（dict），收集所有的关键字参数。
'''
def func(name, *hoby):
    print("I am ", name, "I like", hoby)
func('lili', 'flower', 'money')

def func(**kwargs):
    print(kwargs)
    print(type(kwargs))
func(x = 1, y = 2)



'''1、阅读以下Python程序，
        for i in range(10,5,-1):
            print(i)
        请在下面写出打印结果'''
for i in range(10,5,-1):
    print(i,end='  ')
print()
#乘法表倒过来写
for i in range(9,0,-1):
    for k in range(1,i+1):
        print('%2d*%2d=%2d'%(k,i,k*i),end='  ')
    print()


#列表(list)和元组(tuple)的区别
#集合(set)是怎样的一种数据类型，何时使用？
'''
list是一种有序的集合，可以随时添加和删除其中的元素
tuple和list非常类似，但是tuple一旦初始化就不能修改
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
set集合，是一个无序且不重复的元素集合。
'''


#列表截取
seq = [1,2,3,4]
print(seq[:])       #[1, 2, 3, 4]
print(seq[:2])      #[1, 2]
print(seq[-2:])     #[3, 4]
print(seq[10:])     #[]
print(seq[::-1])    #[4, 3, 2, 1]
print(id(seq[:]) == id(seq))    #False


#优化以下程序
'''result = []
for x in range(10):
    result.append(x**2)
print(result)'''
result=[x**2 for x in range(10)]
print(result)


#函数、类方法定义中如何实现可选参数、可选关键词参数
def funcTest(a,b,c=100,*args,**kwargs):
    numSum=0
    sum=a+b+c
    for num in args:
        numSum+=num
    for value in kwargs.values():
        numSum+=value
    print(args)                 #(10,)
    print(kwargs)               #{'d': 10, 'e': 10}
    print(numSum)               #30

funcTest(10,10,10,10,d=10,e=10)


#请解释classmethod和staticmethod的区别
'''
通常在类中定义一个方法时，系统都会默认带上一个self参数，这样的方法称之为实例方法；
静态方法以@staticmethod装饰器进行装饰，它相当于一个写在类的作用域中的普通方法；
静态方法，访问不了实例的属性，只能访问类的属性
静态方法也无法创建实例
类方法以@classmethod装饰器进行装饰，它有一个系统默认参数cls，代表的是当前类，我们可以通过这个cls()去创建一个类的实例；
类方法，访问不了实例的属性，只能访问类的属性
'''
class Person(object):

    def __init__(self,name,age):
        self.name=name
        self.age=age

    # 实例方法，只能通过实例去调用
    def run(self):
        print(self.name+' is running......')

    # 类方法，访问不了实例的属性，只能访问类的属性
    # 可以通过cls创建类的实例
    @classmethod
    def cmethon(cls):
        print('hello')
        c=cls('bill',45)
        print(c.name)
        c.run()

    # 静态方法，访问不了实例的属性，只能访问类的属性
    # 静态方法也无法创建实例
    # 静态方法只是一个写在类的定义域内的普通方法而已
    @staticmethod
    def smethon():
        print('sleeping')



#请给出下列程序的运
'''x=0.5
while x!=1.0:
    print(x)
    x+=0.1'''
#此题考查浮点数比较相等的情况，x != 1.0 这样程序并不会结束
#因为浮点数相等比较不能通过==,应该是一个范围,可以使用 x <= 1.0


#请写一段程序，包含迭代器和生成器的使用
'''
生成器:在Python中，这种一边循环一边计算的机制，称为生成器（Generator）
迭代器：不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后出现StopIteration错误，表示无法返回下一个值
'''
g=(i**2 for i in range(10))
print(next(g))



#请根据age分别对student_tuples及student_objects进行排序
student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
#说明：每一行的三个元素分别代表name, grade, age.
class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age

    def __repr__(self):
        return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),]

'''
知识点：
sorted(iterable,key,reverse)
作用：实现对可迭代对象进行排序
参数一：可迭代对象
参数二：我们可以使用元素的属性或者函数作为key，来进行比较
参数三：排序的规则，默认为升序【False】,reverse=True 降序 reverse=False 升序
注意：返回的是一个列表,不操作原序列
list.sort()
区别：list.sort()操作原本的列表
'''
list1=sorted(student_tuples,key = lambda x : x[2])
list2=sorted(student_objects,key = lambda s : s.age)
print(list1)
print(list2)


#如何使用匿名函数
from functools import reduce
import calendar
#map函数:将传入的函数依次作用于序列中的每一个元素，最后返回一个迭代器
print(list(map(lambda x:x**2,range(1,10))))
print(reduce(lambda x,y:x*y,range(1,10)))
#fillter函数:不会操作原本的序列，返回一个迭代器，
print(list(filter(lambda x:x>0,[10,-19,-34,27])))
#1000~2000之内的闰年【filter函数】
print(list(filter(calendar.isleap,range(1000,2001))))