python入门（下）

python入门（函数，类）

一、函数

1.定义

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

2.函数参数

1.默认参数

• arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
• 默认参数一定要放在位置参数 后面，不然程序会报错。

def functionname(arg1, arg2=v):

2.可变参数

• *args - 可变参数，可以是从零个到任意个，自动组装成元组。

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


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

3.关键字参数

• **kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

def printinfo(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)

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

4.命名关键字参数

• *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。

3.变量作用域

1.闭包

• 是一种特殊的内嵌函数
• 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。

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

    return funY


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

2.递归

# 利用递归
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 fibo(n):
    if n<=1:
        return n
    return fibo(n-1)+fibo(n-2)
 
fibo(11)
lst=list()
for i in range(11):
    lst.append((fibo(i)))
print(lst)
    #print(fibo(i))

二、匿名函数Lambda

1.定义

在 Python 里有两类函数：

• 第一类：用 def 关键词定义的正规函数
• 第二类：用 lambda 关键词定义的匿名函数

2.应用

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

#非函数式编程
def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x

x = [1, 2, 3]
f(x)
print(x)  # [11, 12, 13]

#函数式编程
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]

• 匿名函数 常常应用于函数式编程的高阶函数
• 参数是函数 (filter, map)
• 返回值是函数 (closure)

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

三、类与对象

对象 = 属性 + 方法

class Turtle:  # Python中的类名约定以大写字母开头
    # 属性
    color = 'green'
    weight = 10
    legs = 4
    shell = True

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

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

    def bite(self):
        print('咬死你咬死你!!')
        
tt = Turtle()
tt.bite()  # 咬死你咬死你!!
tt.run()  # 我正在飞快的向前跑...

继承

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 Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')


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


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

self

Python 的 self 相当于 C++ 的 this 指针。

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

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
        
a = Ball()
a.setName("球A")
a.kick()  # 我叫球A,该死的，谁踢我...

常用方法

构造函数

init_(self[, param1, param2…])

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

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
        
a = Ball("球A")  #省略setname这一步
a.kick()

公有，私有

私有：__foo

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量
    def __foo(self): #私有方法
        print("私有")
    def foo(self):
        print("公有")
x=JustCounter()
x.foo()  #公有

继承

一般不用多继承,容易引起混乱

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

class student(people):  #单继承
    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)  #子类覆盖父类构函

class Sample01(Speaker, Student):  #多重继承

组合

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条