天池阿里云python基础 Task3

天池阿里云python基础 Task3

Python基础进阶：从函数到高级魔法方法
day07：函数、Lambda表达式：

函数的定义：
·函数以def关键词开头，后接函数名和圆括号()。
·函数执行的代码以冒号起始，并且缩进。
·return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

def functionname (parameters):
       "函数_文档字符串"
        function_suite
        return [expression]

例：

def printme(str):
    print(str)

printme("好厉害的样子") #使用函数名()的方式调用函数。
str1 = printme('Hello')
print(str1) #该语句输出为None，是否是因为上一条语句已为输出语句了？

好厉害的样子
Hello
None

形参与实参：
实参是一个实实在在存在的参数，是实际占用内存地址的，而形参只是意义上的一种参数，在定义的时候是不占用内存地址的。如上述例子中，str就是一个形参，好厉害的样子是在调用函数时传入的一个实参，它的值被存放在形参str中。

函数参数：
Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：

·位置参数 (positional argument)
·默认参数 (default argument)
·可变参数 (variable argument)
·关键字参数 (keyword argument)
·命名关键字参数 (name keyword argument)
·参数组合

[可变参数]和[关键字参数]的同异总结如下：
可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。
关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。

变量的作用域：
·Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
·定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
·定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
·局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

例：

def discounts(price,rate):
    final_price = price * rate
    return final_price

old_price = float(input('请输入原价：'))
rate = float(input('请输入折扣：'))

new_price = discounts(old_price,rate)
print(new_price)

请输入原价：200.0
请输入折扣：0.98
196.0

注：内嵌函数调用时，它只能在包含其的上一层函数内部被调用。

Lambda(匿名函数)表达式

在 Python 里有两类函数：

·第一类：用 def 关键词定义的正规函数
·第二类：用 lambda 关键词定义的匿名函数
·Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：
lambda argument_list: expression
·lambda - 定义匿名函数的关键词。
·argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
·:- 冒号，在函数参数和表达式中间要加个冒号。
·expression - 只是一个表达式，输入函数参数，输出一些值。
注意：
·expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
·匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：
·参数是函数 (filter, map)
·返回值是函数 (closure)
如，在 filter和map函数中的应用：
·filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

day08：类与对象

对象 = 属性+方法

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

封装：信息隐蔽技术
我们可以使用关键字 class 定义 Python 类，关键字后面紧跟类的名称、分号和类的实现。

例：

class Turtle:

    #属性
    color = 'red'
    weight = 10
    legs = 4
    shell = True
    mouth = '大嘴'

    #方法
    def climb(self):
        print('123')

tt = Turtle()
print(tt)

print(type(tt))

<__main__.Turtle object at 0x000001E50306E488>
<class '__main__.Turtle'>
<class '__main__.Turtle'>
Turtle
123
<class 'type'>

Self是什么?
·Python 的 self 相当于 C++ 的 this 指针。
·类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称（对应于该实例，即该对象本身），按照惯例它的名称是 self。在调用方法时，我们无需明确提供与参数 self 相对应的参数。

(
字典:
dict{key:value} ----{键：值}，在同一个字典中键必须是互不相同的。
)

day09：魔法方法

魔法方法总是被双下划线包围，例如__init__。

魔法方法是面向对象的 Python 的一切，如果你不知道魔法方法，说明你还没能意识到面向对象的 Python 的强大。

魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用。

魔法方法的第一个参数应为cls（类方法） 或者self（实例方法）。

·cls：代表一个类的名称
·self：代表一个实例对象的名称

例：

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

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

rect = Rectangle(4,5)
print(rect.getPeri())
print(rect.getArea())

18
20

del(self) 析构器，当一个对象将要被系统回收之时调用的方法。
Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 1；当程序中有两个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 2，依此类推，如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，因此 Python 就会回收该对象。

大部分时候，Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况，比如对象 a 持有一个实例变量引用对象 b，而对象 b 又持有一个实例变量引用对象 a，此时两个对象的引用计数都是 1，而实际上程序已经不再有变量引用它们，系统应该回收它们，此时 Python 的垃圾回收器就可能没那么快，要等专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环。

例：

class C(object):
    def __init__(self):
        print('into C __init__')

    def __del__(self):
        print('into C __del__')


c1 = C()
# into C __init__
c2 = c1
c3 = c2
del c3
del c2
del c1
# into C __del__

into C __init__
into C __del__

反算术运算符

反运算魔方方法，与算术运算符保持一一对应，不同之处就是反运算的魔法方法多了一个“r”。当文件左操作不支持相应的操作时被调用。

·radd(self, other)定义加法的行为：+
·rsub(self, other)定义减法的行为：-
·rmul(self, other)定义乘法的行为：*
·rtruediv(self, other)定义真除法的行为：/
·rfloordiv(self, other)定义整数除法的行为：//
·rmod(self, other) 定义取模算法的行为：%
·rdivmod(self, other)定义当被 divmod() 调用时的行为
·rpow(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
·rlshift(self, other)定义按位左移位的行为：<<
·rrshift(self, other)定义按位右移位的行为：>>
·rand(self, other)定义按位与操作的行为：&
·rxor(self, other)定义按位异或操作的行为：^
·ror(self, other)定义按位或操作的行为：|
a + b

这里加数是a，被加数是b，因此是a主动，反运算就是如果a对象的__add__()方法没有实现或者不支持相应的操作，那么 Python 就会调用b的__radd__()方法。

增量赋值运算符

·iadd(self, other)定义赋值加法的行为：+=
·isub(self, other)定义赋值减法的行为：-=
·imul(self, other)定义赋值乘法的行为：*=
·itruediv(self, other)定义赋值真除法的行为：/=
·ifloordiv(self, other)定义赋值整数除法的行为：//=
·imod(self, other)定义赋值取模算法的行为：%=
·ipow(self, other[, modulo])定义赋值幂运算的行为：**=
·ilshift(self, other)定义赋值按位左移位的行为：<<=
·irshift(self, other)定义赋值按位右移位的行为：>>=
·iand(self, other)定义赋值按位与操作的行为：&=
·ixor(self, other)定义赋值按位异或操作的行为：^=
·ior(self, other)定义赋值按位或操作的行为：|=

描述符

描述符就是将某种特殊类型的类的实例指派给另一个类的属性。

·get(self, instance, owner)用于访问属性，它返回属性的值。
·set(self, instance, value)将在属性分配操作中调用，不返回任何内容。
·del(self, instance)控制删除操作，不返回任何内容。

定制序列

协议（Protocols）与其它编程语言中的接口很相似，它规定你哪些方法必须要定义。然而，在 Python 中的协议就显得不那么正式。事实上，在 Python 中，协议更像是一种指南。

容器类型的协议

·如果说你希望定制的容器是不可变的话，你只需要定义__len__()和__getitem__()方法。
·如果你希望定制的容器是可变的话，除了__len__()和__getitem__()方法，你还需要定义__setitem__()和__delitem__()两个方法。

迭代器

·迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
·迭代器是一个可以记住遍历的位置的对象。
·迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
·迭代器只能往前不会后退。
·字符串，列表或元组对象都可用于创建迭代器：

例子：用生成器实现斐波那契数列。

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