1. 基础题
#-----2020-02-20------#
'''
#ip地址转整数
def v(addr):
id=[int(x)for x in addr.split('.')]
s=sum(id[i]<<[24,16,8,0][i] for i in range(4))
print(s)
v('127.0.0.1')
#拷贝
import copy
# 浅拷贝
li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]
# 深拷贝
li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]
# 浅拷贝 指向共有的地址
li1 = [1, 2, 3, [4, 5], 6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]
# 深拷贝 重指向
li1 = [1, 2, 3, [4, 5], 6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]
#现有两个元组(('a'),('b')),(('c'),('d'))，请使用python匿名函数生成列表[{'a':'c'},{'b':'d'}]
#匿名函数形式：
li1=(('a'),('b'))
li2=(('c'),('d'))
li3=(('1'),('2'),('3'))
#zip:将对象中对应的元素打包成一个个元组,返回一个对象，其列表长度与最短的对象相同
print(list(zip(li1,li2,li3)))
# map(function, iterable, ...)
ret=map(lambda n:{n[0]:n[1]},zip(li1,li2))
print(list(ret))
#列表表达式形式：
li1=(('a'),('b'))
li2=(('c'),('d'))
print([{n[0]:n[1]} for n in zip(li1,li2)])
v = dict.fromkeys(['k1', 'k2'], [])
v['k1'].append(666)
print(v)#{'k1': [666], 'k2': [666]}
#Python字典(Dictionary)fromkeys()函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值，默认为None。
v1 = dict.fromkeys(['k1', 'k2'])
print(v1) # {'k1': None, 'k2': None}
v2 = dict.fromkeys(['k1', 'k2'], [])
print(v2) # {'k1': [], 'k2': []}
#print(( i % 2 for i in range(10) ))
# <generator object <genexpr> at 0x00000000020CEEB8> 生成器
# 在Python中，有一种自定义迭代器的方式，称为生成器（Generator）。
# 定义生成器的两种方式：
# 1.创建一个generator，只要把一个列表生成式的[]改成()，就创建了一个generator：
# generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，
#没有更多的元素时，抛出StopIteration的错误。
# 2.定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，
#而是一个generator
ef foo():
m=3
n=5
def bar():
a=4
return m+n+a
return bar
#bar在foo函数的代码块中定义。我们称bar是foo的内部函数。
#在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。
#简单的说，这种内部函数可以使用外部函数变量的行为，就叫闭包
import copy
list1=[1,2,3]
list2=list1
list1[1]=4
print(list2)
#or 从左到右，返回第一个为真的值，都为假返回后一个值
#and 从左到右，若所有值均为真，则返回后一个值，有一个假的值，则返回第一个假的值
v1=1 or 3
v2=10 and 3
print(v1,v2)
#函数内改变函数外的变量:global声明全局变量
n=3
def f():
global n
n=4
f()
print(n)
#闭包：内嵌函数引用外层函数的变量，闭包函数返回内嵌函数的地址(函数名称)
def fo():
n=5
def fi():
#n=n+1只可引用，不可修改
print('fi',n+1)
print(n)
print(bool(fi.__closure__))
return fi
f=fo()
print(bool(f.__closure__))
f()
#装饰器
#本质：闭包
#作用：在不修改原函数及其调用方式的情况下对原函数功能进行扩展
#eg:为现有函数f1增加日志功能
#使用闭包
def f1():
print('我是f1')
def outf(func):
def inf():
func()
print('写日志')
return inf
f1=outf(f1)
f1()
#使用装饰器（语法糖）
def outf(func):
def inf():
func()
print('写日志')
return inf
@outf
def f1():
print('我是f1')
f1()
#多个装饰器
def d1(func):
print('装饰器1即将装饰：')
def d():
return func()+" 1正在装饰 "
return d
def d2(func):
print('装饰器2即将装饰：')
def d():
return func()+" 2正在装饰 "
return d
@d2
@d1
def f1():
return ' 我是毛坯房 '
print(f1())
#通用装饰器
def func(fn):
# 需要有参数，*args,**kwargs
def func_in(*args,**kwargs):# args：非键值参数 kwargs：键值参数
print("记录日志")
print('访问方法:'+fn.__name__)
# 需要有参数，*args,**kwargs
xx = fn(*args,**kwargs)
# 需要有返回值
return xx
return func_in
@func
def test(n,str):
print(n,str)
test(3,'hi')
# 类方法静态方法
# 静态方法：
# 1.格式：在方法上面添加 @staticmethod
# 2.参数：静态方法可以有参数也可以无参数
# 3.应用场景：一般用于和类对象以及实例对象无关的代码。
# 4.使用方式： 类名.类方法名(或者对象名.类方法名)
# 使用示例： 学生管理系统的展示主菜单
# 类方法：
# 无需实例化，可以通过类直接调用的方法，但是方法的第一个参数接收的一定是类本身
# 1.在方法上面添加@classmethod
# 2.方法的参数为 cls 也可以是其他名称，但是一般默认为 cls
# 3.cls 指向 类对象(也就是 Goods)
# 4.应用场景：当一个方法中只涉及到静态属性的时候可以使用类方法(类方法用来修改类属 性)。
# 5.使用 可以是 对象名.类方法名。或者是 类名.类方法名
class Goods():
count=1
def __init__(self,name,price):
self.name=name
self.price=price
def discount(self):
return self.price*self.count
@classmethod
def changcount(cls,new_count):
cls.count=new_count
print(Goods.count)
Goods.changcount(3)
print(Goods.count)
