【python入门】函数，类和对象

【大家好，我是爱干饭的猿，本文重点介绍python入门的函数，高阶函数，python中的类和对象，模块的作用等。

后续会继续分享其他重要知识点总结，如果喜欢这篇文章，点个赞👍，关注一下吧】

上一篇文章：《【Android ADB】常见ADB命令》

1. 函数

定义函数：
def 函数名(参数):
  函数体

---

注意：与其他语言不同的是传递实参给形参时，传递的是地址 ，
也就是改变形参的值也会直接改变实参的值！
python内的函数可以嵌套定义

python函数返回多个值
直接return a,n,d #a,n,d是需要返回的值
这个利用了python，这时a,n,d，自动类型转换成为了一个元组

def hanshu()
    return a,n,d

b,c,v = hanshu()
#利用元组的解包
1
2
3
4
5

1.1 不定长求和函数

def sum(*a):
    result = 0
    for i in a:
        result +=i
    print(result)
sum(1, 2, 3, 4)
#输出为：10
1
2
3
4
5
6
7

方法利用了元组
这种方法使用时，若函数还有其他参数，需要用到关键字参数
例如：

def p(a,*b,c):
    print("a=", a)
    print("b=", b)
    print("c=", c)


p(2, 3, 4, 5, c=6)
1
2
3
4
5
6
7

输出为：

a= 2
b= (3, 4, 5)
c= 6
1
2
3

*形参只能接收位置形参，不能接收关键字形参

1.2 参数解包

def e(a, b, c):
    print("a=", a)
    print("b=", b)
    print("c=", c)


c = (1, 2, 3) #元组
d = {"a": 1, "b": 2, "c": 3} #字典
e(*c)
e(**d)
1
2
3
4
5
6
7
8
9
10

输出为：

a= 1
b= 2
c= 3
a= 1
b= 2
c= 3
1
2
3
4
5
6

*对元组进行解包将其个值赋给形参

**对字典进行解包将其值赋给形参

注意：元组或字典内元素个数要和形参个数一致

1.3 文档字符串

def(a:int, b:float, c:int)

可以对函数的参数进行描述，其需要一个什么类型的值，但是不是强制要求

用’‘‘这里面写文档，会保留文档格式’’’

在函数内写对函数进行描 述
用help(函数名)可查看

1.4 高阶函数

高阶函数至少要符合以下两个特点中的一个

• 接收一个或多个函数作为参数
• 将函数作为返回值返回

def fn2():
    print(2)

def fn1(fun):
    fun

if __name__ == '__main__':
    fn1(fn2())
1
2
3
4
5
6
7
8

filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中

参数:

1. 函数，根据该函数来过滤序列(可迭代的结构)
2. 需要过滤的序列(可迭代的结构)

返回值:

1. 过滤后的新序列( 可迭代的结构)

1.5 匿名函数

用lambda来定义一般函数定义用的是def
这种函数一般用于一个函数的参数，简单的函数计算等

例1：
a = 7
# f是参数 f>5是返回值
b = (lambda f: f > 5)(a) #传参
print(b)
#输出为：true

例2：
l = [1, 2, 3, 4, 5]
r = filter(lambda i : i % 2 == 1, l)
print(list(r)) 

例3：
# map()函数可以对可跌倒对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
l = [1, 2, 3, 4, 5]
r = map(lambda i : i + 1, l)
print(list(r))

例4：
# sort()
#该方法用来对列表中的元素进行排序
#sort()方法默认是直接比较列表中的元素的大小
#在sort()可以接收一个关键字参数, key
#key需要一个函数作为参数，当设置了函数作为参数
l =[ "bb' , 'aaaa' ,'c' , 'ddddddddd', 'fff']
l.sort(key=len)
l =[2, 5, '1', 3, '6', '4']
l.sort( key=int)
print(l)
#sorted()
#这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
#并且使用sorted()排序不会影响原来的对象，而是返回一个新对象


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1.6 闭包

将函数作为返回值返回，也是一种高阶函数

这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量，可以将一些私有的数据藏到的闭包中。

形成闭包的要件：

① 函数嵌套

② 将内部函数作为返回值返回

③ 内部函数必须要使用到外部函数的变量

def make_averager():
    # 创建一个列表，用来保存数值
    nums = []

    # 创建一个函数，用来计算平均值
    def averager(n) :
        # 将n添加到列表中
        nums.append(n)
        # 求平均值
        return sum(nums)/len(nums)

    return averager

averager = make_averager()

print(averager(10))
print(averager(20))
print(averager(30))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.7 装饰器

希望函数可以在计算前，打印开始计算，计算结束后打印计算完毕
我们可以直接通过修改函数中的代码来完成这个需求，但是会产生以下一些问题
① 如果要修改的函数过多，修改起来会比较麻烦
② 并且不方便后期的维护
③ 并且这样做会违反开闭原则（OCP）
程序的设计，要求开发对程序的扩展，要关闭对程序的修改

当我们不确定函数的参数数量时，我们使用*args、***kwargs作为参数。Python允许我们将可变数量的参数或非键值对参数 *args、***kwargs传递给函数。

Python可以使用*args传递多个参数，但是不能使用它来传递键值对（字典）参数。Python另一个名为 **kwargs的参数允许我们将字典类型的键值对参数传递给函数。

# 创建几个函数

def add(a , b):
    '''
        求任意两个数的和
    '''
    r = a + b
    return r


def mul(a , b):
    '''
        求任意两个数的积
    '''
    r = a * b
    return r


def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function

f2 = begin_end(add)
f3 = begin_end(mul)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

向begin_end()这种函数我们就称它为装饰器
通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
在开发中，我们都是通过装饰器来扩展函数的功能的
在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
可以同时为一个函数指定多个装饰器，这样函数将会安装从内向外的顺序被装饰

def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数
    return new_function

@fn3
@begin_end
def say_hello():
    print('大家好~~~')

say_hello()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2. 类和对象

2.1 对象

• 对象是内存中专门用来存储数据的一块区域。
• 对象中可以存放各种数据（比如：数字、布尔值、代码）
• 对象由三部分组成：
  1.对象的标识（id）
  2.对象的类型（type）
  3.对象的值（value）

2.2 类

类和对象都是对现实生活中的事物或程序中的内容的抽象

实际上所有的事物都由两部分构成：

1. 数据（属性）
2. 行为（方法）

在类的代码块中，我们可以定义变量和函数，

• 变量会成为该类实例的公共属性，所有的该类实例都可以通过 对象.属性名 的形式访问
• 函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名() 的形式调用方法

注意：
方法调用时，第一个参数由解析器自动传递，所以定义方法时，至少要定义一个形参！

实例为什么能访问到类中的属性和方法
类中定义的属性和方法都是公共的，任何该类实例都可以访问

• 属性和方法查找的流程
  当我们调用一个对象的属性时，解析器会先在当前对象中寻找是否含有该属性，
  如果有，则直接返回当前的对象的属性值，
  如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值，
  如果类对象中依然没有，则报错！

• 类对象和实例对象中都可以保存属性（方法）

  • 如果这个属性（方法）是所有的实例共享的，则应该将其保存到类对象中
  • 如果这个属性（方法）是某个实例独有，则应该保存到实例对象中

• 一般情况下，属性保存到实例对象中
  而方法需要保存到类对象中

isinstance()#检查一个实例，用的类是不是那个

class MyClass():
    pass


my = MyClass()
result = isinstance(my, MyClass)
print(result)
#输出为 true
1
2
3
4
5
6
7
8

---

# 尝试定义一个表示人的类
class Person:
    # 在类的代码块中，我们可以定义变量和函数
    # 在类中我们所定义的变量，将会成为所有的实例的公共属性
    # 所有实例都可以访问这些变量
    name = 'chm'  # 公共属性，所有实例都可以访问

    # 在类中也可以定义函数，类中的定义的函数，我们称为方法
    # 这些方法可以通过该类的所有实例来访问

    def say_hello(self):
        # 方法每次被调用时，解析器都会自动传递第一个实参
        # 第一个参数，就是调用方法的对象本身，
        #   如果是p1调的，则第一个参数就是p1对象
        #   如果是p2调的，则第一个参数就是p2对象
        # 一般我们都会将这个参数命名为self

        # say_hello()这个方法，可以显示如下格式的数据：
        #   你好！我是 xxx
        #   在方法中不能直接访问类中的属性
        print('你好！我是 %s' % self.name)


# 创建Person的实例
p1 = Person()
p2 = Person()

# print(p2.name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.3 特殊方法

特殊方法，也称为魔术方法
特殊方法都是使用__开头和__结尾的
特殊方法一般不需要我们手动调用，需要在一些特殊情况下自动执行
1
2
3

class MyClass:
    
    # init会在对象创建以后离开执行
    # init可以用来向新创建的对象中初始化属性
    # 调用类创建对象时，类后边的所有参数都会依次传递到init()中
    def __init__(self,name):
        self.name = name

    # del是一个特殊方法，它会在对象被垃圾回收前调用
    def __del__(self):
        print('A()对象被删除了~~~',self)


my = MyClass("chm")

del my
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def __init__(self)方法，在实例创建是自动执行
def __del__(self)方法，相当于c++的析构函数，在对象使用完被回收时，使用。在Python中有自动的垃圾回收机制，它会自动将这些没有被引用的对象删除
1
2

2.4 创建对象的流程

p1 = Person()的运行流程
1.创建一个变量
2.在内存中创建一个新对象
3.init(self)方法执行
4.将对象的id赋值给变量

2.5 封装

为类中每一个变量设置get，set两个函数，使类封装起来，来得到或设置变量，不想让别人直接调用变量修改，个人认为利于界面化操作，接触不到底层代码时使用。

class MyClass:
    def __init__(self,name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name

    def hello(self):
        print("word")


my = MyClass("chm")

print(my.get_name())
my.set_name("yy")
print(my.get_name())
#输出：chm yy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

修改name属性为_name告诉别人，不允许修改，但是只是告诉想修改还是可以的，给出get_name , set_name 方法给用户，用来查看和修改.

隐藏属性：
可以为对象的属性使用双下划线开头，__xxx
双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问，其实隐藏属性只不过是Python自动为属性改了一个名字，实际上是将名字修改为了，_类名__属性名 比如 __name -> _Person__name

使用__开头的属性，实际上依然可以在外部访问，所以这种方式我们一般不用
一般我们会将一些私有属性（不希望被外部访问的属性）以_开头
1
2
3
4
5
6

2.6 property装饰器

class MyClass:
    def __init__(self, age, name):
        self._age = age
        self._name = name
	
    # property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法
    # 使用property装饰的方法，必须和属性名是一样的
    @property
    def age(self):
        return self._age

    # setter方法的装饰器：@属性名.setter
    @age.setter
    def age(self, age):
        self._age = age


my = MyClass(22, "jj")
print(my.age)
my.age = 18
print(my.age)
#输出：22 18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

每个get方法前面加@property，每个set方法前面加@方法名.setter，在进行函数调用时，可以省略（），看着像是在调用变量一样，使用时@property，@方法名.setter，需要同时出现，或者只出现第一个

2.7 继承

通过继承我们可以使一个类获取到其他类中的属性和方法

在定义类时，可以在类名后的括号中指定当前类的父类（超类、基类、super）
子类（衍生类）可以直接继承父类中的所有的属性和方法

通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合OCP原则，所以我们经常需要通过继承来对一个类进行扩展

class Animal(object):
    def run(self):
        print("它会跑")

    def eat(self):
        print("它会吃")


class Dog(Animal):
    pass


d = Dog()
d.run()
print(isinstance(d, Dog))
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))
print(issubclass(Animal, object))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出为：

它会跑
True
True
True
True
1
2
3
4
5

继承在定义类时后加括号加入父类
所有类的父类都是object可以省略

isinstance()验证某个实例是不是来源于某个类
issubclass()验证某个类的是不是它的父类

2.8 方法重写

如果在子类中如果有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们成为叫做方法的重写（覆盖，override）

当我们调用一个对象的方法时：

1. 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
2. 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
3. 如果没有，则去父类的父类中寻找，以此类推，直到找到object，如果依然没有找到，则报错

class A(object):
    def test(self):
        print('AAA')

class B(A):
    def test(self):
        print('BBB')

class C(B):
    def test(self):
        print('CCC')

# 创建一个c的实例
c = C()
c.test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.9 super()关键字

子类中定义了与父类同名的方法，通过子类实例调用方法时，会调用子类的方法，发生了函数覆盖。

注意：

当子类继承了父类的一个方法，但是方法的参数有很多，子类只有新增的一些参数需要修改，用函数覆盖，写函数时，不像再初始化那些不变的参数，这时可以调用父类的参数来初始化属性。

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

    def run(self):
        print('动物会跑~~~')

    def sleep(self):
        print('动物睡觉~~~')

    @property
    def name(self):
        return self._name

    @name.setter    
    def name(self,name):
        self._name = name

# 父类中的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法
class Dog(Animal):

    def __init__(self,name,age):
        # 希望可以直接调用父类的__init__来初始化父类中定义的属性
        # super() 可以用来获取当前类的父类，
        #   并且通过super()返回对象调用父类方法时，不需要传递self
        super().__init__(name)
        self._age = age

    def bark(self):
        print('汪汪汪~~~') 

    def run(self):
        print('狗跑~~~~')   

    @property
    def age(self):
        return self._age

    @age.setter    
    def age(self,age):
        self._age = name        

d = Dog('旺财',18) 

print(d.name)       
print(d.age)       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

super()可以获取当前类的父类

2.10 多重继承

在Python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
可以在类名的()后边添加多个类，来实现多重继承
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
在开发中没有特殊的情况，应该尽量避免使用多重继承，因为多重继承会让我们的代码过于复杂，如果多个父类中有同名的方法，则会现在第一个父类中寻找，然后找第二个，然后找第三个
前边父类的方法会覆盖后边父类的方法

class C(A,B):
    pass
1
2

2.11 多态

面向对象中，多态性，指只要你还有某种属性就可以调用
不在意类型，体现多态的灵活性

# 定义两个类
class A:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name


class B:
    def __init__(self, name):
        self._name = name

    def __len__(self):
        return 10

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name


class C:
    pass


a = A('孙悟空')
b = B('猪八戒')
c = C()


# 定义一个函数--多态
# 对于say_hello()这个函数来说，只要对象中含有name属性，它就可以作为参数传递
#   这个函数并不会考虑对象的类型，只要有name属性即可
def say_hello(obj):
    print('你好 %s' % obj.name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 在say_hello_2中我们做了一个类型检查，也就是只有obj是A类型的对象时，才可以正常使用，
#   其他类型的对象都无法使用该函数，这个函数就违反了多态
# 违反了多态的函数，只适用于一种类型的对象，无法处理其他类型对象，这样导致函数的适应性非常的差
# 注意，向isinstance()这种函数，在开发中一般是不会使用的！
def say_hello_2(obj):
    # 做类型检查
    if isinstance(obj, A):
        print('你好 %s' % obj.name)
    # say_hello(b)


# say_hello_2(b)

# 鸭子类型
# 如果一个东西，走路像鸭子，叫声像鸭子，那么它就是鸭子

# len()
# 之所以一个对象能通过len()来获取长度，是因为对象中具有一个特殊方法__len__
# 换句话说，只要对象中具有__len__特殊方法，就可以通过len()来获取它的长度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

面向对象的三大特征：
  封装
      - 确保对象中的数据安全
  继承
      - 保证了对象的可扩展性
  多态
      - 保证了程序的灵活性
1
2
3
4
5
6
7

2.12 类中的属性和方法总结

类属性：直接在类中定义的属性
属性可以通过类或类的实例访问到
但是类属性只能通过类对象来修改，无法通过实例对象修改

---

实例属性：通过实例对象添加的属性
实例属性只能通过实例对象来访问和修改，类对象无法访问和修改

---

实例方法：在类的定义中，以self为第一参数的方法都是实例方法
实例方法在调用时，python会调用实例对象作为self传入
当通过类调用时，不会自动传递self，此时需要手动传递一个实例对象在类对象的参数中

---

类方法：在类的内部使用@classmethod来修饰的方法属于类方法
类方法的第一个参数是cls，也会自动传递，cls就是当前的类对象

---

类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
类方法可以通过类去调用也可以通过实例调用，没有区别

---

静态方法：在类中使用@staticmethod来修饰的方法
静态方法不需要指定任何默认参数，静态方法可以通过类和实例对象去调用
静态方法，基本与的当前类无关，就是一个保存到当前类的一个函数

# 定义一个类
class A(object):

    # 1. 类属性，直接在类中定义的属性是类属性
    #   类属性可以通过类或类的实例访问到
    #   但是类属性只能通过类对象来修改，无法通过实例对象修改
    count = 0

    def __init__(self):
        # 2. 实例属性，通过实例对象添加的属性属于实例属性
        #   实例属性只能通过实例对象来访问和修改，类对象无法访问修改
        self.name = '孙悟空'

    # 3. 实例方法
    #   在类中定义，以self为第一个参数的方法都是实例方法
    #   实例方法在调用时，Python会将调用对象作为self传入  
    #   实例方法可以通过实例和类去调用
    #       当通过实例调用时，会自动将当前调用对象作为self传入
    #       当通过类调用时，不会自动传递self，此时我们必须手动传递self
    def test(self):
        print('这是test方法~~~ ' , self)    

    # 4. 类方法    
    # 在类内部使用 @classmethod 来修饰的方法属于类方法
    # 类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象
    #   类方法和实例方法的区别，实例方法的第一个参数是self，而类方法的第一个参数是cls
    #   类方法可以通过类去调用，也可以通过实例调用，没有区别
    @classmethod
    def test_2(cls):
        print('这是test_2方法，他是一个类方法~~~ ',cls)
        print(cls.count)

    # 5. 静态方法
    # 在类中使用 @staticmethod 来修饰的方法属于静态方法  
    # 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例去调用  
    # 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
    # 静态方法一般都是一些工具方法，和当前类无关
    @staticmethod
    def test_3():
        print('test_3执行了~~~')


a = A()
# 实例属性，通过实例对象添加的属性属于实例属性
# a.count = 10
# A.count = 100
# print('A ,',A.count) 
# print('a ,',a.count) 
# print('A ,',A.name) 
# print('a ,',a.name)   

# a.test() 等价于 A.test(a)

# A.test_2() 等价于 a.test_2()

A.test_3()
a.test_3()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2.13 特殊方法

特殊方法，也称为魔术方法
特殊方法都是使用__开头和结尾的
特殊方法一般不需要我们手动调用，需要在一些特殊情况下自动执行

# 定义一个Person类
class Person(object):
    """人类"""

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

    # __str__（）这个特殊方法会在尝试将对象转换为字符串的时候调用
    # 它的作用可以用来指定对象转换为字符串的结果  （print函数）
    def __str__(self):
        return 'Person [name=%s , age=%d]' % (self.name, self.age)

        # __repr__()这个特殊方法会在对当前对象使用repr()函数时调用

    # 它的作用是指定对象在 ‘交互模式’中直接输出的效果
    def __repr__(self):
        return 'Hello'

        # object.__add__(self, other)

    # object.__sub__(self, other)
    # object.__mul__(self, other)
    # object.__matmul__(self, other)
    # object.__truediv__(self, other)
    # object.__floordiv__(self, other)
    # object.__mod__(self, other)
    # object.__divmod__(self, other)
    # object.__pow__(self, other[, modulo])
    # object.__lshift__(self, other)
    # object.__rshift__(self, other)
    # object.__and__(self, other)
    # object.__xor__(self, other)
    # object.__or__(self, other)

    # object.__lt__(self, other) 小于 <
    # object.__le__(self, other) 小于等于 <=
    # object.__eq__(self, other) 等于 ==
    # object.__ne__(self, other) 不等于 !=
    # object.__gt__(self, other) 大于 >
    # object.__ge__(self, other) 大于等于 >=

    # __len__()获取对象的长度

    # object.__bool__(self)
    # 可以通过bool来指定对象转换为布尔值的情况
    def __bool__(self):
        return self.age > 17

    # __gt__会在对象做大于比较的时候调用，该方法的返回值将会作为比较的结果
    # 他需要两个参数，一个self表示当前对象，other表示和当前对象比较的对象
    # self > other
    def __gt__(self, other):
        return self.age > other.age


# 创建两个Person类的实例
p1 = Person('孙悟空', 18)
p2 = Person('猪八戒', 28)

# 打印p1
# 当我们打印一个对象时，实际上打印的是对象的中特殊方法 __str__()的返回值
# print(p1) # <__main__.Person object at 0x04E95090>
# print(p1)
# print(p2)

# print(repr(p1))

# t = 1,2,3
# print(t) # (1, 2, 3)

# print(p1 > p2)
# print(p2 > p1)

# print(bool(p1))

# if p1 :
#     print(p1.name,'已经成年了')
# else :
#     print(p1.name,'还未成年了')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

3. 模块

模块（module）
模块化，模块化指将一个完整的程序分解为一个一个小的模块
  通过将模块组合，来搭建出一个完整的程序
不采用模块化，统一将所有的代码编写到一个文件中
采用模块化，将程序分别编写到多个文件中
  模块化的有点：
      ① 方便开发
      ② 方便维护
      ③ 模块可以复用！

在Python中一个py文件就是一个模块，要想创建模块，实际上就是创建一个python文件
注意：模块名要符号标识符的规范

在一个模块中引入外部模块
① import 模块名 （模块名，就是python文件的名字，注意不要py）
② import 模块名 as 模块别名
  - 可以引入同一个模块多次，但是模块的实例只会创建一个
  - import可以在程序的任意位置调用，但是一般情况下，import语句都会统一写在程序的开头
  - 在每一个模块内部都有一个__name__属性，通过这个属性可以获取到模块的名字
  - __name__属性值为 __main__的模块是主模块，一个程序中只会有一个主模块
      主模块就是我们直接通过 python 执行的模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.1 包 package

包也是一个模块，当我们模块中代码过多时，或者一个模块需要被分解为多个模块时，这时就需要使用到包。
普通的模块就是一个py文件，而包是一个文件夹
包中必须要一个一个 init.py 这个文件，这个文件中可以包含有包中的主要内容

from hello import a , b

print(a.c)
print(b.d)
1
2
3
4

3.2 __pycache__文件夹

该文件为模块的缓存文件避免重复编译

__pycache__ 是模块的缓存文件
py代码在执行前，需要被解析器先转换为机器码，然后再执行
  所以我们在使用模块（包）时，也需要将模块的代码先转换为机器码然后再交由计算机执行
  而为了提高程序运行的性能，python会在编译过一次以后，将代码保存到一个缓存文件中
  这样在下次加载这个模块（包）时，就可以不再重新编译而是直接加载缓存中编译好的代码即可
1
2
3
4
5

3.3 python标准库

为了实现开箱即用的思想，Python中为我们提供了一个模块的标准库

部分列举如下：

# 开箱即用
# 为了实现开箱即用的思想，Python中为我们提供了一个模块的标准库
# 在这个标准库中，有很多很强大的模块我们可以直接使用，
#   并且标准库会随Python的安装一同安装
# sys模块，它里面提供了一些变量和函数，使我们可以获取到Python解析器的信息
#   或者通过函数来操作Python解析器
# 引入sys模块
import sys

# pprint 模块它给我们提供了一个方法 pprint() 该方法可以用来对打印的数据做简单的格式化
import pprint

# sys.argv
# 获取执行代码时，命令行中所包含的参数
# 该属性是一个列表，列表中保存了当前命令的所有参数
# print(sys.argv)

# sys.modules
# 获取当前程序中引入的所有模块
# modules是一个字典，字典的key是模块的名字，字典的value是模块对象
# pprint.pprint(sys.modules)

# sys.path
# 他是一个列表，列表中保存的是模块的搜索路径

# sys.platform
# 表示当前Python运行的平台
# print(sys.platform)

# sys.exit()
# 函数用来退出程序
# sys.exit('程序出现异常，结束！')
# print('hello')

# os 模块让我们可以对操作系统进行访问
import os

# os.environ
# 通过这个属性可以获取到系统的环境变量
# pprint.pprint(os.environ['path'])

# os.system()
# 可以用来执行操作系统的名字
# os.system('dir')
# os.system('notepad')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45