阿里天池-python训练营3

2. 函数
2.1 函数定义
2.2 函数文档
2.3 help方法
2.4 函数参数
2.5 函数的返回值
2.6 变量作用域
2.7 模块/函数的导入
3. Lambda 匿名函数
3.1 Lambda函数的定义
3.2 匿名函数的应用
4. 类与对象
4.1 定义
4.2 self 是什么？
5. Python 的魔法方法
5.1 公有和私有
5.2 类的组合应用
5.3 类、类对象和实例对象
5.4 绑定
5.5 一些相关的内置函数（BIF）
6. 魔法方法
6.1 基本的魔法方法
6.2 算术运算符
6.3 反算术运算符
6.4 增量赋值运算符
6.5 一元运算符
6.6 属性的访问
6.7 描述符
6.8 定制序列
6.9 迭代器
6.10 生成器
1. 阿里云天池Python教程链接 (3)
阿里云天池教程(3) （点击打开链接）

2. 函数
2.1 函数定义
以 def 关键词开头，后接函数名和圆括号()。
函数体代码以冒号开始，并且缩进。
return (表达式) 结束函数，选择性返回一个值给调用方。默认返回None。
def myrequests(url, level):
'''定义个性化的reqeusts函数, 设置headers和time out的默认参数'''
    pass
    print("html downloaded")
    return html

myrequests(url = "https:XXX", level = 0)
1
2
3
4
5
6
7
2.2 函数文档
一般在 def 下一行, 使用三引号, 简述函数功能。

2.3 help方法
建议在每个自定义函数/模块中都建立一个help 方法, 可使用 help(function_name) 调用, 提示函数的功能及用法。

2.4 函数参数
位置参数: 在调用时位置需固定
默认参数 (def function_name(arg1, arg2=v)), 放在位置参数后面
可变参数 (def function_name(arg1, arg2=v, *args)), 可以是零个到任意个，*args 将其组装成元组
关键字参数 (def function_name(arg1, arg2=v, **kwargs)), 可以是零个到任意对，**kw 将其组装成字典
命名关键字参数 - 限制调用者可以传入的参数名，同时可提供默认值
使用组合参数 (keep simple please)
def printinfo(arg1, *args, **kwargs):
    print(arg1, args, kwargs)

printinfo(70, 60, 50, a=1, b=2)
# 70, (60, 50), {'a': 1, 'b': 2}

# 命名关键字参数
def printinfo(arg1, *, nkw, **kwargs):
    print(arg1, nkw, kwargs)

printinfo(70, nkw=10, a=1, b=2)
# 70, 10, {'a': 1, 'b': 2}
1
2
3
4
5
6
7
8
9
10
11
12
2.5 函数的返回值
可以返回任何任何类型的值，如字典，列表，元组等。

def add(a, b):
    return a + b

print(add([1, 2, 3], [4, 5, 6]))  # [1, 2, 3, 4, 5, 6]
1
2
3
4
2.6 变量作用域
访问权限决定于这个变量是在哪里赋值的。

全局变量: 在内部作用域修改外部作用域的变量时，需要使用 global 关键字。

num = 1
def fun1():
    global num  # 全局变量声明
    print(num)  # 1
    num = 123
    print(num)  # 123

fun1()
print(num)  # 123
1
2
3
4
5
6
7
8
9
内嵌函数作用域

def outer():
    print('outer is here')

    def inner():
        print('inner is here')

    inner()

outer()
# outer is here
# inner is here
1
2
3
4
5
6
7
8
9
10
11
闭包，一种特殊的内嵌函数。
在一个内部函数里对外层的非全局作用域的变量进行引用。

def outer_f(x):
    def inner_f(y):
        return x * y
    return inner_f

i = outer_f(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40
1
2
3
4
5
6
7
8
修改闭包作用域中的变量使用 nonlocal 关键字。

def outer():
    num = 10

    def inner():
        nonlocal num
        num = 100
        print(num)

    inner()
    print(num)

outer()
# 100
# 100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
递归: 一个函数在内部调用其自身。

# n! = 1 x 2 x 3 x ... x n
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5)) # 120

# 斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1
def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)

lst = list()
for k in range(11):
    lst.append(recur_fibo(k))
print(lst) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

# 修改 Python默认的递归层数。默认值为100
import sys
sys.setrecursionlimit(1000)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2.7 模块/函数的导入
将函数存储为扩展名为 .py 的文件，作为可以复用的模块。

在需要调用时导入，导入方法：

import requests # 导入一个模块
from bs4 import BeautifulSoup # 导入模块中的一个函数
import xlwings as xw  # 导入时指定别名，简化在文件中的调用
1
2
3
3. Lambda 匿名函数
3.1 Lambda函数的定义
语法结构：lambda argument_list: expression

argument_list - 可以是位置参数、默认参数、关键字参数，和函数里的参数类型一样。
没有 return 语句，因为表达式的结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
lbd_sqr = lambda x: x ** 2
print(lbd_sqr) # <function <lambda> at 0x000000BABB6AC1E0>

y = [lbd_sqr(x) for x in range(10)]
print(y) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

sumary = lambda arg1, arg2: arg1 + arg2
print(sumary(10, 20))  # 30

func = lambda *args: sum(args)
print(func(1, 2, 3, 4, 5))  # 15
1
2
3
4
5
6
7
8
9
10
11
3.2 匿名函数的应用
常应用于函数式编程的高阶函数中，主要有两种形式：

参数是函数 (filter, map)
返回值是函数 (closure)
# 使用filter(function, iterable) 过滤序列，返回一个迭代器对象，可使用list()转换为列表。
odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

# map(function, *iterables) 根据提供的函数对指定序列做映射
m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1)) # [1, 4, 9, 16, 25]

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 apply_to_list(fun, some_list):
    return fun(some_list)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
4. 类与对象
4.1 定义
类主要定义对象的结构，属性和方法。然后以类为模板创建对象，对象是类的实例。

使用关键字 class 定义 Python 的类，关键字后面紧跟类的名称、分号和类的实现。

建议类名使用驼峰体，即单词首字母都大写，如ElecCar。

封装：对外隐蔽信息

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

    # 定义类的方法
    def climb(self):
        print('我正在很努力的向前爬...')
        
tt = Turtle()
print(tt) # <__main__.Turtle object at 0x0000007C32D67F98>
print(type(tt)) # <class '__main__.Turtle'>
print(tt.__class__) # <class '__main__.Turtle'>
print(tt.__class__.__name__) # Turtle

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
继承：子类自动共享父类的属性和方法

class MyList(List):
    pass

lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
print(lst) # [1, 5, 2, 7, 8, 9]
1
2
3
4
5
6
多态：不同类的对象对同一方法的响应不同

class Animal:
    def run(self):
        raise AttributeError('子类须自行实现这个方法')

class People(Animal):
    def run(self):
        print('人正在走')

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

def func(animal):
    animal.run()

func(Dog()) # dog is running

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
4.2 self 是什么？
类的方法与普通的函数有一个区别，就是必须有一个额外的第一个参数（对应于该实例，即该对象本身），按照惯例它的名称是 self。在调用方法时，无需明确提供与参数 self 相对应的参数。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)

t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# <class '__main__.Test'>
1
2
3
4
5
6
7
8
9
5. Python 的魔法方法
即 Python 的对象天生拥有的方法。

类有一个名为__init__的魔法方法，该方法在类实例化时会自动调用。

class Ball:
    def __init__(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,谁踢我..." % self.name)

a = Ball("球A")
a.kick() # 我叫球A, 谁踢我...
1
2
3
4
5
6
7
8
9
5.1 公有和私有
定义私有变量需在变量名或函数名前加上两个下划线。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)

counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2

# Python的私有为伪私有，还是可以被外部调用显示的
print(counter._JustCounter__secretCount)  # 2 
print(counter.__secretCount) # AttributeError: 'JustCounter' object has no attribute '__secretCount'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
继承：Python 同样支持类的继承

父类必须与子类定义在一个作用域内。

如果子类中定义了与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

尽量不使用多继承，避免引起混乱。

# 类定义
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)
        # 也可以这样继承
        # super().__init__()
        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 年级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
5.2 类的组合应用
class Turtle:
    def __init__(self, x):
        self.num = x

class Fish:
    def __init__(self, x):
        self.num = x

class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))

p = Pool(2, 3)
p.print_num() # 水池里面有乌龟2只，小鱼3条

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
5.3 类、类对象和实例对象
类对象：类也是一个对象，称为类对象。也在内存开辟了一块空间。
实例对象：通过实例化类创建的对象称为实例对象，可以有多个。
类属性：所有通过该类实例化的对象都能共享该类的属性。
实例属性：实例属性和某个具体的实例相关联。谁调用它，它的值就属于谁。
注意：应避免属性与方法名称相同，否则方法会被属性定义覆盖。
class A(object):
    a = 0  #类属性
    def __init__(self, xx):
        A.a = xx  #使用类属性可以通过 （类名.类属性）调用。

# 实例化对象 a、b、c，都属于实例对象。
a = A()
b = A()
c = A()
1
2
3
4
5
6
7
8
9
5.4 绑定
只有实例才能调用类的方法。

对象的属性通常存储在名为.__ dict__的字典中，可访问__dict__或使用函数 vars () 获取。

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

    def printXY(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}
print(CC.__dict__) # {'__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}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
5.5 一些相关的内置函数（BIF）
issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
一个类也是其自身的子类。
classinfo可以是类对象的元组，只要class是其中任何一个类的子类，就返回True。
class A:
    pass

class B(A):
    pass

print(issubclass(B, A))  # True
print(issubclass(B, B))  # True
print(issubclass(A, B))  # False
print(issubclass(B, object))  # True
1
2
3
4
5
6
7
8
9
10
isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。
type()不会认为子类是一种父类类型，不考虑继承关系。而 isinstance()认为子类是一种父类类型。
如果第一个参数不是对象，则返回False。如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。
a = 2
print(isinstance(a, int))  # True
print(isinstance(a, str))  # False
print(isinstance(a, (str, int, list)))  # True

class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# hasattr(object, name)用于判断对象是否包含对应的属性
class Coordinate:
    x = 10

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
print(getattr(a, 'bar2')) # AttributeError: 'A' object has no attribute 'bar2'

# setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的
class A(object):
    bar = 1

a = A()
print(getattr(a, 'bar'))  # 1
setattr(a, 'bar', 5)
print(a.bar)  # 5
setattr(a, "age", 28)
print(a.age)  # 28

# delattr(object, name)用于删除属性
class Coordinate:
    x = 10
    y = -5
    z = 0

point1 = Coordinate()

print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5
print('z = ', point1.z)  # z =  0

delattr(Coordinate, 'z')

print('--删除 z 属性后--')  # --删除 z 属性后--
print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5
print('z = ', point1.z) # AttributeError: 'Coordinate' object has no attribute 'z'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值。

fget – 获取属性值的函数
fset – 设置属性值的函数
fdel – 删除属性值函数
doc – 属性描述信息
class C(object):
    def __init__(self):
        self.__x = None

    def getx(self):
        return self.__x

    def setx(self, value):
        self.__x = value

    def delx(self):
        del self.__x

    x = property(getx, setx, delx, "I'm the 'x' property.")

cc = C()
cc.x = 2
print(cc.x)  # 2

del cc.x
print(cc.x) # AttributeError: 'C' object has no attribute '_C__x'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
6. 魔法方法
魔法方法总是被双下划线包围，如__init__。

魔法方法的第一个参数应为cls（类方法） 或self（实例方法）。cls 代表一个类的名称, self 代表一个实例对象的名称。

6.1 基本的魔法方法
new(cls[, …])

实例化一个对象时调用的第一个方法（在调用__init__初始化前）。
至少需要一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__。
当继承一些不可变的 class 时 (如str)，这个方法提供了自定义的途径。
class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return str.__new__(cls, string)

a = CapStr("i love lsgogroup")
print(a)  # I LOVE LSGOGROUP
1
2
3
4
5
6
7
init(self[, …]) ：一个实例被创建时调用的初始化方法。
del(self)：当一个对象将要被系统回收时调用的方法。

class Rectangle:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def getPeri(self):
        return (self.x + self.y) * 2

rect = Rectangle(4, 5)
print(rect.getPeri())  # 18
1
2
3
4
5
6
7
8
9
10
str(self): 打印，使用str强转数据类型的时候将会触发
repr(self)：str的备胎
str 的意义是得到便于阅读的信息，__repr__的返回结果更准确，便于开发者使用。
6.2 算术运算符
add(self, other)定义加法的行为：+
sub(self, other)定义减法的行为：-
mul(self, other)定义乘法的行为：*
truediv(self, other)定义真除法的行为：/
floordiv(self, other)定义整数除法的行为：//
mod(self, other) 定义取模算法的行为：%
divmod(self, other)定义当被 divmod() 调用时的行为
divmod(a, b)把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
pow(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
lshift(self, other)定义按位左移位的行为：<<
rshift(self, other)定义按位右移位的行为：>>
and(self, other)定义按位与操作的行为：&
xor(self, other)定义按位异或操作的行为：^
or(self, other)定义按位或操作的行为：|
6.3 反算术运算符
与算术运算符一一对应，不同之处就是多了一个“r”。当文件左操作不支持相应的操作时被调用。

例如：radd(self, other)定义加法的行为：+ 。

6.4 增量赋值运算符
与算术运算符一一对应，不同之处就是多了一个“+”。

例如：iadd(self, other)定义赋值加法的行为：+=。x +=1 等同于 x = x +1

6.5 一元运算符
neg(self)定义正号的行为：+x
pos(self)定义负号的行为：-x
abs(self)定义当被abs()调用时的行为
invert(self)定义按位求反的行为：~x
6.6 属性的访问
getattr(self, name): 定义当用户试图获取一个不存在的属性时的行为。
getattribute(self, name)：定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存在，接着去调用__getattr__）。
setattr(self, name, value)：定义当一个属性被设置时的行为。
delattr(self, name)：定义当一个属性被删除时的行为。
6.7 描述符
描述符就是将某种特殊类型的类的实例指派给另一个类的属性。

get(self, instance, owner)用于访问属性，它返回属性的值。
set(self, instance, value)将在属性分配操作中调用，不返回任何内容。
del(self, instance)控制删除操作，不返回任何内容。
6.8 定制序列
定制不可变容器，需定义__len__()和__getitem__()方法。

定制可变容器，除了以上两个方法，还需要定义__setitem__()和__delitem__()方法。

len(self)定义当被len()调用时的行为（返回容器中元素的个数）。
getitem(self, key)定义获取容器中元素的行为，相当于self[key]。
setitem(self, key, value)定义设置容器中指定元素的行为，相当于self[key] = value。
delitem(self, key)定义删除容器中指定元素的行为，相当于del self[key]。
6.9 迭代器
是访问集合元素的一种方式。从集合的第一个元素开始访问，直到所有的元素被访问完。
迭代器可以记住遍历的位置的对象。
字符串，列表或元组对象都可用于创建迭代器。
links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}
for each in links:
    print('%s -> %s' % (each, links[each]))
    
'''
B -> 百度
A -> 阿里
T -> 腾讯
'''

for each in iter(links):
    print('%s -> %s' % (each, links[each]))
1
2
3
4
5
6
7
8
9
10
11
12
迭代器有两个基本的方法：iter() 和 next()。

iter(object) 函数用来生成迭代器。
next(iterator[, default]) 返回迭代器的下一个项目。iterator – 可迭代对象。default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}

it = iter(links)
while True:
    try:
        each = next(it)
    except StopIteration:
        break
    print(each)

# B
# A
# T

it = iter(links)
print(next(it))  # B
print(next(it))  # A
print(next(it))  # T
print(next(it))  # StopIteration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
6.10 生成器
使用了 yield 的函数被称为生成器（generator）。生成器是一个返回迭代器的函数，只能用于迭代操作。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

def myGen():
    print('生成器执行！')
    yield 1
    yield 2
    
myG = myGen()
for each in myG:
    print(each)

'''
生成器执行！
1
2
'''

myG = myGen()

print(next(myG))  
# 生成器执行！
# 1

print(next(myG))  # 2
print(next(myG))  # StopIteration

# 使用生成器实现斐波那契数列
def libs(n):
    a = 0
    b = 1
    while True:
        a, b = b, a + b
        if a > n:
            return
        yield a

for each in libs(100):
    print(each, end=' ')
# 1 1 2 3 5 8 13 21 34 55 89