import time
scale = 10
print("----执行开始----")
for i in range(scale+1):
    a = "*" * i#'*'重复i次
    b = '.' * (scale - i)#.重复(scale-i)次
    c = i/scale * 100
    print("{:^3.0f}%[{}->{}]".format(c,a,b))#^指居中对齐，3指输出宽度为3；.0f指保留0位小数
    time.sleep(0.1)#循环每执行一次休眠0.1s
print("----执行结束----")

感觉还挺有趣的，我比较新手就记一下，方便复习

def make_Counter(init):
    counter = [init]
    def inc(): counter[0] += 1
    def dec(): counter[0] -= 1
    def get(): return counter[0]
    def reset(): counter[0] = init
    return inc, dec, get, reset #这个和内嵌函数的顺序是要一一对应的

（话说Functools里其实有Counter, 类似都是统计个数的）
让咋们执行模拟一下

inc, dec, get, reset = make_counter(0)
inc()
inc()
print(get()) # 2
dec()
print(get()) # 1
reset()
print(get()) # 0

还有闭包作用域内变量是需nonlocal keyword

def outer():
    num = 10

    def inner():
        nonlocal num  # nonlocal关键字声明
        num = 100
        print(num)

    inner()
    print(num)
####    执行一下    ####
outer()
# 100 这就修改了inner外部（即outer）的值
# 100

递归默认层数 100， 修改可用

sys.setrecursionlimit(1000) #当然要先import sys

2. Lambda表达式

喜闻乐见， Lee215最爱
new_f = lambda arugment(s,) : experssion
比如

square = lambda x : x ** 2
#或者多个
sum_of_squared = lambda x, y, z : x**2+y**2+z**2
---
y = [square(i) for i in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
###     用可变参数* a      ##
func = lambda *a:sum(a)
print(func(1,2,3,4,5))
# 15

函数式编程 是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

def f(x):
    y = []
    for item in x:
        y.append(item + 10)
    return y
x = [1, 2, 3]
f(x)
print(x)
# [1, 2, 3]

使用map 做映射 (不止可以map int噢)

m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]

或者自定义高阶函数:

def mmap(func, lists1):
    return func(lists1)

然后输入数据和匿名函数

数据 = [1, 2, 3, 4, 5]
print(mmap(sum, 数据))
# 15
print(mmap(len, 数据))
# 5
print(mmap(lambda x: sum(x) / len(x), 数据))
# 3.0

类 Class
对象 Object = attribute + method 属性 + 方法

class Turtle:  # Python中的类名约定以大写字母开头
    """关于类的一个简单例子"""
    # 属性
    color = 'green'
    weight = 10
    legs = 4
    shell = True
    mouth = '大嘴'

    # 方法
    def climb(self):
        print('我正在很努力的向前爬...')

    def run(self):
        print('我正在飞快的向前跑...')

    def bite(self):
        print('咬死你咬死你!!')

    def eat(self):
        print('有得吃，真满足...')

    def sleep(self):
        print('困了，睡了，晚安，zzz')


tt = Turtle()
print(tt)
# <__main__.Turtle object at 0x0000007C32D67F98>

print(tt.__class__.__name__)
# Turtle

tt.climb()
# 我正在很努力的向前爬...

tt.run()
# 我正在飞快的向前跑...

tt.bite()
# 咬死你咬死你!!

# Python类也是对象。它们是type的实例
print(type(Turtle))
# <class 'type'>

继承

class mlist(list):
    pass
LIST = mlist([1,5, 6, 2, 9])
LIST.append(4)
LIST.sort()
print(LIST)
# [1, 2, 4, 5, 6, 9]

class Pig(Animal):
    def run(self):
        print('pig is walking')


class Dog(Animal):
    def run(self):
        print('dog is running')


def func(animal):
    animal.run()

func(Pig())
# pig is walking

注 Pig().run() 一样可以，不过写成func(Pig()) 调类显得正式规范些

类的方法 需要有一个self参数表示对象本身。

class Ball:
    def setName(self, name):
        self.name = name
    def kick(self):
        print("blah%s" % self.name)

a= Ball()
a.setName("球A")
a.kick()
# blah球A

直接用__init__

class Ball:
    def __init__(self, name):
        self.name = name
    def kick(self):
        print(" 啊这%s, 就这" % self.name)

a= Ball("球A")
a.kick()
#  啊这球A, 就这

私有变量：变量前加两个__
不过是伪私有，硬调还是能调出来

class JustCounter:
    __私有和 = 0  # 私有变量
    公和 = 0  # 公开变量

    def count(self):
        self.__私有和 += 1
        self.公和 += 1
        print(self.__私有和)
print(counter._JustCounter__私有和)  # 2 

Class inheritage and Overwrite

class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

6. 绑定

对象的数据属性通常存储在名为. dict

class CC:
    def setXY(self, x, y):
        self.x = x
        self.y = y
    def print1(self):
        print(self.x, self.y)

#
dd = CC()
print(dd.__dict__)
# {}
print(vars(dd))
# {}
print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000C3473DA048>, 'printXY': <function CC.printXY at 0x000000C3473C4F28>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}
print(vars(CC))
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

7. 内置函数 BIF

issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

class A:
    pass

class B(A):
    pass

print(issubclass(B, A)) # True
print(issubclass(A, B)) # False
print(issubclass(B, object)) # True

isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。
但他认为子类继承父类类型，type不考虑。

a = 2
print(isinstance(a, int))  # True
print(isinstance(a, str))  # False
print(isinstance(a, (str, int, list)))  # True

hasattr(object, name)用于判断对象是否包含对应的属性。

class Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()
print(hasattr(point1, 'x'))  # True
print(hasattr(point1, 'no'))  # False

getattr(object, name[, default])用于返回一个对象属性值。

class A(object):
    bar = 1


a = A()
print(getattr(a, 'bar'))  # 1
print(getattr(a, 'bar2', 3))  # 3