python的查漏小知识（2）

上一个博客汇总了一些常用的、我又还不太熟悉的知识点，但还都是简单的，比较难的部分是函数、类。之前通过一些例子学习过函数和类，还做过笔记，这次当成复习吧。

1. 函数

1.1 概念

1. 一个程序由一个个任务组成，函数就代表一个任务；
2. 函数是可重用的代码块。编写函数时，涉及到函数体、函数调用、传递参数和返回结果等内容。

1.2 函数的分类

很基本也经常打交道的概念，我觉得可以了解一下。

1. 内置函数，e.g. len()、str()、eval()等等；
2. 标准库函数，e.g. numpy中的range()、pandas中的DataFrame()等，通过import语句导入库后，使用其中定义的函数；
3. 第三方库函数，下载安装对应的库后，import导入后调用；
4. 自定义函数。

1.3 函数定义与调用

为了增加程序的可读性，一般建议在定义函数之后附上说明，用三个单引号实现。

1.4 return语句

1.5 全局变量与局部变量

1.6 lambda表达式

f = lambda a, b, c: a + b + c
print(f)
print(f(1, 2, 3))
>>> <function <lambda> at 0x000001E6FE34E828>
>>> 6

记下语法规则，我总是以为lambda后面有逗号而报错。

# 如果将lambda()改为函数
def f(a, b, c):
    return a+b+c

d = f(1, 2, 3)
print(d)    # 6

1.7 函数中传入参数与不传参数区别

def fibs():
    li = list()
    for i in range(n-2):
        li.append(i)
    print(li)

n = 5
fibs()

>>>  [0,1,2]


# 或

def fibs():
    li = list()
    for i in range(n-2):
        li.append(i)
    return li

n = 5                  #如果函数没有传参数进去，那变量的命名要和函数中的变量命名相同
l = fibs()
print(l)

>>> [0,1,2]



# 或给函数传入参数：
def fibs(n):
    li = list()
    for i in range(n-2):
        li.append(i)
    return li

l = fibs(5)
print(l)

1. 传入参数和不传参数；
2. 有return和没有return。

2. 类

前面学习到的数据类型（list、dict、str等等）、函数都是对象，随着编程面临的问题越复杂，从数据变多进化出“数组”，数据类型变复杂，进化出“结构体”，处理数据的方式和逻辑变复杂，进化出“对象”。

2.1 类的定义

要点：

1. 类名一般规定，首字母大写，多个单词使用“驼峰原则”；
2. 类体中定义属性和方法；
3. 属性用来描述数据，方法（即函数）用来描述这些数据的相关操作。
   例子：
   
   __init__函数
   
   实例属性：
   i) . 一般在__init__函数中定义：self.实例属性名 = 初始值
   ii). 创建实例对象，调用 __init__函数初始化属性，可以进行赋值。
   e.g. :

s1 = Student()
s1.name = '张三'
s1.score = '80'

实例方法：

2.2 python中为什么有些函数在定义的时候需要传入self参数，有些不需要？

在类中定义的函数需要传入self参数，表示对象本身。在普通函数中不用传入这个参数。

2.3 类带括号和不带括号的区别

不带括号： 赋值
带括号： 创建对象 object
参考资料：Python中类-带括号与不带括号的区别

2.4 定义class时有括号和没有括号，有参数和没有参数

1. 有括号而且后面有参数，表示继承，比如 class A(B): 表示A继承B；
2. 没有括号或括号后没有参数（两者等价），表示不继承。

2.5 私有属性和私有方法

1. 两个下划线开头的属性是私有的（private），其它为公共的（public）；
2. 类内部可以访问私有属性、类外部不能直接访问私有属性；
3. 类外部可以通过‘对象名.__类名__私有属性’ 访问私有属性。

2.6 为什么写程序一般要用if name == ‘main’？

2.7 怎么调用函数和类

2.7.1 在同一文件夹下

2.7.2 在不同文件夹下

参考资料：导入类

3. 继承

继承可以让子类具有父类的特性，提高了代码的重用性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def say_age(self):
        print(self.name, self.__age)

class Student(Person):
    def __init__(self, name, age, score):
        self.score = score

s1 = Student('xiaoxi', 15, 85)
s1.say_age()                   #  AttributeError: 'Student' object has no attribute 'name'

报错了，因为Student中没有定义name和age。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def say_age(self):
        print(self.name, self.__age)

class Student(Person):
    def __init__(self, name, age, score):
        self.score = score
        Person.__init__(self, name, age)   # 子类并不会自动调用父类的__init__()，要自己调用。
        print(self.name, self.score)

s1 = Student('xiaoxi', 15, 85)   #   xiaoxi 85
s1.say_age()    

自己写个类和继承体会一下：

class Dog():
    '''关于狗的描述'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def run(self):
        print(self.name.title() + " is now running.")

    def roll_over(self, color):
        print(self.name.title() + " is a " + color + "'s dog, and it rolled over!")

my_dog = Dog('Lucy', 6)
my_dog.run()
my_dog.roll_over('color')

>>>  Lucy is now running.
     Lucy is a color's dog, and it rolled over!

注意体会self.name和color

写一个继承：

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    """关于狗的描述"""
    def __init__(self, name, age, color):
        Animal.__init__(self, name, age)
        self.color = color
    
    def run(self):
        """小狗被命令跑"""
        print(self.name.title() + " is now running.")

    def roll_over(self):
        """可以在这个函数中加上独特的属性"""
        print(self.name.title() + " is a " + self.color + "'s dog, and it rolled over!")

my_dog = Dog('Lucy', 6, 'black')
my_dog.run()
my_dog.roll_over()

>>>  Lucy is now running.
     Lucy is a color's dog, and it rolled over!

Dog()继承了Animal类中的name和age定义。