009 Python语法之函数总结与面向对象

简书地址：http://www.jianshu.com/p/9bf43eb2c113

1. 函数

函数的定义

• 函数就是我们将一些功能封装起来,减少一部分类似的代码

例子(如果有一百个类似的需求,那么函数就显得很方便了)

1. 求1-10的和
sum1 = 0
for i in range(11):
    sum1 += i
print("sum1：", sum1)

2. 求1-100的和
sum1 = 0
for i in range(101):
    sum1 += i
print("sum1：", sum1)

3. 用函数的方式编程(n可以随意改变,适合所有类似的需求)
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i
    return sum1

print("sum1：", getSum(n))

函数什么时候需要返回值

1. 为什么需要返回值

• 有一些函数需要这个函数处理一些数据后返回数据给你,比如 math.sqrt(n) ,这个函数会返回 n 的二分之一次方,外界需要这个值去操作其它东西

2. 什么时候需要返回值

求和函数需要一个求出来的和,这个就是需要返回值
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i
    return sum1

global关键字

1. 什么是global

• global是一个关键字,这个关键字可以将函数内部的局部变量变成全局变量

1. 这种情况外部不能访问函数内部的局部变量
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i

getSum(101)
print(sum1)     --> 这个sum1是不能被外部访问到的

2. 加上global后就能调用了
def getSum(n):
    global sum1
    sum1 = 0
    for i in range(n):
        sum1 += i

getSum(101)
print(sum1)     --> 这个sum1是能被访问到的

2. 什么时候需要global

• 个人很不建议使用global关键字,第3点会讲解

这种外部不能访问函数内部的局部变量情况下可以使用global
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i

getSum(101)
print(sum1)     --> 这个sum1是不能被外部访问到的

3. global需要注意的事情

def getSum(n):
    global sum1
    sum1 = 0
    for i in range(n):
        sum1 += i

sum1 = 0    --> 这个是外部的变量：sum1
getSum(n)
print(sum1)     --> 这个sum1是能被访问到的
一旦外部也有sum1变量的时候,

函数的可变参数(可变参数是一个元组传递到函数中)

1. 什么时候需要可变参数

1. 求两个数的和
def getSum(n1, n2):
    return n1 + n2

2. 求三个数的和
def getSum(n1, n2, n3):
    return n1 + n2 + n3

3. 求四个数的和
def getSum(n1, n2, n3, n4):
    return n1 + n2 + n3 + n4

这个时候,我就可以使用可变参数,在参数这个位置，你可以传递任意多个参数
def getSum(*n1):
    sum1 = 0
    for item in n1:
        sum1 += item
    return sum1

2. 可变参数与普通参数混合后的缺点

• 一旦你的可变参数与普通参数混合了,那么就会出现问题

这个结果就会报错,按照我们正常思维三个数求和应该等于 6 才对,但是函数分不清你的参数 3 是 n1 的还是 n2 的
def getSum(*n1, n2):
    sum1 = 0
    for item in n1:
        sum1 += item
    return sum1

getSum(1,2,3)   


解决这个问题可以将可变参数放在参数列表最后面来解决
def getSum(n1, *n2):
    sum1 = 0
    for item in n2:
        sum1 += item
    return sum1

函数参数的默认值

1. 优点

• 不容易报错,哪怕你没有写函数的参数

2. 缺点

• 不利于编程,容易让你依赖不写参数

这个时候就可以不写参数也能调用,因为参数有一个默认值 1,但是不建议不写
def max1(n1 = 1):
    return n1

print(max1())


如果你在参数中传递 2,那么n1的值就会赋值为 2
def max1(n1 = 1):
    return n1

print(max1(2))

不同文件之间的函数的调用

1. 为什么需要不同文件之间函数调用

2. 不同注意点

局部变量与全局变量

1. 局部变量与全局变量的概念

• 局部变量就是只在某一个代码块中变量(for循环中,函数中,while循环中)
• 全局变量就是在一个文件的任何地方都能访问到的变量

2. 作用域

• 作用域就是你for中的变量你只能在for中访问,外面访问不到

for item in range(10):
    num1 = 1
print(num1)  --> for语句的外面就访问不到for语句中的num1,
这个for语句的语句块就是num1的作用域

内嵌函数与闭包

1. 什么是内嵌函数

• 一个函数内部定义的函数(fun2函数)

def fun1():
    print("fun1 ing")
    def fun2():
        print("fun2 ing")

    fun2()  # 内嵌函数的定义和调用都必须在外层函数中

fun1()

2. 什么是闭包

• 闭包就是外面这层函数(fun1函数)

3. 内嵌函数的使用

• 内嵌函数只能在函数的内部使用

2. 面向对象

面向过程与面向对象

1. 什么是面向过程(自己买菜)

1. 首先准备钱
2. 准备出门
3. 去菜市场
4. 选菜
5. 买菜
6. 回家
7. 做饭等等

2. 什么是面向对象(委托别人买菜)

1. 把钱给A,委托A买菜
2. A把菜给你

3. 面向对象的优势

• 面向对象把处理事务的一些细节都隐藏了,大大提高了开发效率

4. 类定义格式

1. init()函数是每一个类对象都有函数,在创建对象的时候会调用,比如 cat1 = Cat(“JFCat”, 2) 的时候

class Cat:
    gender = "默认值"
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self)
        print("一个叫%s,年龄为%d的Cat在吃鱼")


cat1 = Cat("JFCat", 2)
print(cat1.name)    -->  "JFCat"
print(cat1.age)     -->  2
print("默认值")

1. 类变量

1. 上面的 gender 就是类变量

2. 类方法(对象的行为)

1. eat方法就是类方法

3. 实例变量

1. self.name,self.age就是实例变量

私有变量

私有变量的格式

1. 以双下划线开头的实例变量就是私有变量

self.__变量名 = ""

类内部访问私有变量的方式

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    def getRadius(self):
        return self.__radius

这里外部不能访问 __radius 属性
c1 = Circle(5)
c1.__radius 和 c1.radius 都不能访问到 radius 这个私有变量
-----------------------
下面这种方式才能访问私有变量
c1.getRadius()这个能访问到 self.__radius 这个私有变量的值

类外部访问私有变量的方式

1. Python私有变量在类内部的命名特性,根据 name mangling 技术,私有变量的名字都会变成(_类名__变量名)的形式

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    def getRadius(self):
        return self.__radius

c1 = Circle(5)
c1._Circle__radius 这个能访问到 self.__radius

私有方法

1. Python私有方法在类内部的命名特性,根据 name mangling 技术,私有变量的名字都会变成(_类名__变量名)的形式

类外部访问私有方法的方式

1. 通过正常的方法外部是无法访问函数内部的私有方法

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    def __getRadius(self):
        return self.__radius

c1 = Circle(5)
c1._Circle__getRadius() 这个能访问到 __getRadius() 方法

可变与不可变对象

1. 可变对象在将自己传递出去的时候,经过运算自己的值就会被改变
2. 不可变对象在将自己传递出去的时候,经过运算自己的值就不会被改变

不可变对象

1. 不可变对象：数字(包括浮点数)、字符串、布尔

def max(n1, n2):
    n1 = 200
    n2 = 300

n1 = 1
n2 = 2
----------------------
print(n1)
print(n2)
n1 和 n2 还是 1,不会改变

可变对象

1. 可变对象：列表、元组、集合、字典、类对象

def change(list1):
    list1[0] = 0

list1 = ["123", "abc", "789"]
change(list1)
----------------------
print(list1)
list1 被改变了

总结

函数与面向对象都是一个难点，没有编程基础的需要在这两块上面好好下功夫。