Python基础进阶：从函数到高级魔法方法

Day_3

一、函数

函数的定义

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

注：
1.不带表达式的return相当于返回None
2.Python 把函数也当成对象，可以从另一个函数中返回出来而去构建高阶函数，比如： 参数是函数、返回值是函数。

函数参数
1.位置参数
2.默认参数
调用函数时，默认参数的值如果没有传入，则被认为是默认值。默认参数一定要放在位置参数 后面
3.可变参数
可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args):
       "函数_文档字符串"
       function_suite
       return [expression]

args - 可变参数，可以是从零个到任意个，自动组装成元组。
加了星号（*）的变量名会存放所有未命名的变量参数。

def printinfo(arg1, *args):
    print(arg1)
    for var in args:
        print(var)


printinfo(10)  # 10
printinfo(70, 60, 50)
# 70
# 60
# 50

4.关键字参数

def functionname(arg1, arg2=v, args, *kw):
       "函数_文档字符串"
       function_suite
       return [expression]

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

5.命名关键字参数
6.参数组合

变量作用域
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了
闭包
是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

def funX(x):
    def funY(y):
        return x * y

    return funY


i = funX(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40

Lambda表达式

在 Python 里有两类函数：

第一类：用 def 关键词定义的正规函数
第二类：用 lambda 关键词定义的匿名函数
Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression

lambda - 定义匿名函数的关键词。
argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
:- 冒号，在函数参数和表达式中间要加个冒号。
expression - 只是一个表达式，输入函数参数，输出一些值。
注意：

expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

类与对象

对象 = 属性+方法
1.封装
2.继承：子类自动共享父类之间数据和方法的机制

class MyList(list):
    pass

lst = MyList([1,5,2,7,8])
lst.append(9)
lst.sort()
print(lst) # [1, 2, 5, 7, 8, 9]

【例子】如果子类中定义与父类同名的方法或属性，会自动父类对应的方法或属性

# 类定义
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 年级

class student(people):
    grade = ''
     
    def __init__(self, n, a, w, g):
        self.grade = g
        
    def speak(self):
        print('%s 说：我 %d 岁了，我在读 %d 年级' %(self.name, self.age, self.grade))
        
s = student('小马的程序人生', 10, 60, 3)
s.speak()  #说：我 0 岁了，我在读 3 年级

3.多态：不同对象对同一方法响应不同的行动

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

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

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

func(Pig())  # pig is walking

一些相关的内置函数
isinstance(object,classinfo)方法用于判断一个对象是否是一个已知的类型

魔法方法

迭代器
字符串，列表或元组对象都可用于创建迭代器
两个基本方法：iter() 和 next()

生成器
使用yield的函数被称为生成器
生成器是一个返回迭代器的函数，只能用于迭代操作，生成器就是一个迭代器