#Python实例属性的初始化

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):
   def __init__(self, name, sex, age):
       self.name = name
       self.sex = sex
       self.age = age
__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。
定义类后，就可以相应的实例化对象了，需要注意的是，

在实例化的时候，需要提供除self以外的所有参数。

在Python中，通过class关键字定义一个类

类名以大写字母开头

定义的三种方法：

class Person:  pass

class Person(): pass

class Person(object):  pass

定义了类之后，就可以对类进行实例化了，实例化是指，把抽象的类，赋予实物的过程

创建实例使用类名+()

class Person(object):  pass 

xiaohong = Person()

#8-11 Python编写有参数的decorator  ----------------------不会也不熟练
#上一节的@performance只能打印秒，请给 @performace 增加一个参数，允许传入's'或'ms'：
import time
from functools import reduce

def performance(unit):
   def performance_decorator(f):
       def wrapper(*args,**kwargs):
           start_t=time.time()
           result= f(*args,**kwargs)
           stop_t=time.time()
           #interval=(stop_t-start_t) if unit=='s' else (stop_t-start_t)*1000
           interval = (stop_t-start_t) * 1000 if unit == 'ms' else (stop_t-start_t)   #这种在后面加if...else的写法以前少见，多看看
           print('call {}() in {}{}'.format (f.__name__, interval,unit))
           return result
       return wrapper
   return performance_decorator

@performance('ms')
def factorial(n):
   time.sleep(1)
   return reduce(lambda x,y:x*y,range(1,n+1))
print(factorial(10))
# print('call %s() in %f()()' % (f.__name__, (start_t - stop_t),unit)) #这种写法有问题
# TypeError: not all arguments converted during string formatting 不是所有的参数在字符串格式化期间转换
# 输出结果
# 当unit=ms时--> 1018.0001258850098ms
# 当unit=s时-->1.0s

#8-10 Python编写无参数的decorator       ---------------------------------------------------没学会--------------------
#Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数
#功能：使用装饰器可以对已有的函数增加新的功能，避免多次编写相同功能的函数     ---开放封闭原则
#什么是装饰器？定义一个函数，该函数可为其他函数添加额外的功能。
#何时用装饰器？ 需要在不修改被装饰对象源代码及其调用方式时，为被装饰对象添加额外的功能
#被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数执行它自己内部的代码后，会将它的返回值赋值给被装饰的函数。　
#只能放在被装饰的函数的上方最近处，不要空行！！！！！！！！！！
#自己的理解：只要用装饰符@XXX，就可以给被装饰对象添加额外的功能了，而且似乎语法结构很相似？--应该是有模板的，模板类似下文
'''
def outter(func):
   def wrapper(*args,**kwargs):        #自适应任何参数定义的函数:利用Python的 args 和 *kwargs，保证任意个数的参数总是能正常调用：
       #1、调用原函数
       #2、增加的新功能
       res=func(*args,**kwargs)
       return res
   return wrapper
#使用时
@outter
def func():
   pass
'''

'''
from functools import reduce

def log(f):
   def fn(x):
       print('call ' + f.__name__ + '()...')
       return f(x)
   return fn
@log
def factorial(n):
   return reduce(lambda x,y: x*y, range(1, n+1))

print(factorial(10))    # 输出结果：  call factorial()...
                       #           3628800
'''

#@装饰器名字，等价于f=performance(f)
#请编写一个@performance，它可以打印出函数调用的时间。
import time
from functools import reduce

def performance(f):
   def fn(*args, **kw):
       t1 = time.time()
       r = f(*args, **kw)
       t2 = time.time()
       print('call %s() in %fs' % (f.__name__, (t2 - t1)))
       return r
   return fn

@performance
def factorial(n):
   return reduce(lambda x,y: x*y, range(1, n+1))
print(factorial(10))
# 输出结果
# call factorial() in 0.000000s
# 3628800

'''

#请编写一个@performance，它可以打印出函数调用的时间。
import time
from functools import reduce

def performance(f):
   def fn(*args,**kwargs):
       start_t = time.time()
       #print(start_t)
       result = f(*args, **kwargs)
       #这里result放置的位置有区别吗？放在这或者更往下的位置stop_t下面，放在这里才是对的，否则其实被装饰函数里写了time.sleep(1)也不生效，start_t和stop_t的时间是一样的,所以意思是被装饰的函数体其实会在这里被调用吗？
       stop_t = time.time()
       #print(stop_t)
       print('call %s() in %fs' %(f.__name__, (start_t-stop_t))) 

         #这个格式化写法需要多看看，之前不熟悉
       return result
   return fn

@performance
def factorial(n):
   time.sleep(1)
   return reduce(lambda x,y:x*y,range(1,n+1))
print(factorial(10))

'''

#这道题答案很简单，为什么自己花费了时间还是做不出来呢？？思路接近，但是还是有不对的，如先转成小写再比较。最开始想的是只有str类型有lower方法，所以定义函数时，返回的是str类型

# 8-6 Python自定义排序函数
# 对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。
# 输入：['bob', 'about', 'Zoo', 'Credit']
# 输出：['about', 'bob', 'Credit', 'Zoo']
def is_lower(x):
   return str(x).lower()
L=['bob', 'about', 'Zoo', 'Credit']
Llower = list(is_lower(L))
print(type(Llower))
result=sorted(Llower)    #为什么用sorted(Llower)排序的时候，是按照字符分割后的结果进行排序的呢？？
print(result)

#参考答案如下

def k(item):
   return item.lower()

sorted(['bob', 'about', 'Zoo', 'Credit'], key=k)

#请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：1, 4, 9, 16, 25, 36, 49, 64, 81, 100。
import  math
def f(x):
   r = int(math.sqrt(x))
   return r*r == x
L= [i for i in range(1,101)]
for item in filter(f,L):
   print(item)

#题目对我来说的难点：

1、平方根是整数的数 该怎么表示(sqrt)  

2、#1~100该怎么表示 (range(1,101)),最开始没想到什么简便的方法，于是想到了
# 利用推导式来赋值，其实这里直接用range(1,101)即可。

#原理：某个数的平方还在这个列表里 但是该怎么表示呢？不能用成员运算符in，否则会报错，应该用r*r==x这种形式。
# return的时候究竟返回的是哪个值这个还需要多了解

# Python的reduce()函数
# Python内置了求和函数sum()，但没有求积的函数，请利用recude()来求积
# 输入：[1, 3, 5, 7, 9]
# 输出：13579的结果
from functools import reduce
def f(x,y):
   return x*y
result= reduce(f,[1,3,5,7,9])
print(result)
#输出结果应该是945吧？为什么题目说的是13579的结果。。。

def f(x):

    return  str.capitalize(x)

name_list=[]

for name in map(f,['alice', 'BOB', 'CanDY']):

    name_list.append(name)

print(name_list)

#<method 'capitalize' of 'str' objects>   没有给capitalize加参数()导致的
#capitalize() 将字符串的第一个字母变成大写,其他字母变小写

#我的答案特意将输出结果转成了列表形式，参考答案没有，是str类型

#以下是参考答案
def format_name(s):
   return s[0].upper() + s[1:].lower()
for item in map(format_name, ['alice', 'BOB', 'CanDY']):
   print(item)

python3的语法中，class父类是可以不用写object

此处为python2的语法

把count改为私有__count，这样实例变量在外部无法修改__count:

            私有化就是在外部无法访问，只能在类的内部可以进行访问

初始方法一init ＿－

cat.name='kitty'

cat.age='1'

print(cat.name)

Print(cat.age)

Class Animals(object): pass cat=Animals () dog=Animals

isinstance()内置函数用于判断一个对象是否是一个已知的类型，类似type()，区别是考虑继承关系。     语法：isinstance(object, classinfo)；

object -- 实例对象。

classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。