【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,db,c,v = hanshu()
#利用元组的解包

1.1 不定长求和函数

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

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

def p(a,*b,c):print("a=", a)print("b=", b)print("c=", c)p(2, 3, 4, 5, c=6)

输出为：

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

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

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)

输出为：

a= 1
b= 2
c= 3
a= 1
b= 2
c= 3

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

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

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

1.3 文档字符串

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

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

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

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

1.4 高阶函数

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

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

def fn2():print(2)def fn1(fun):funif __name__ == '__main__':fn1(fn2())

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.6 闭包

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

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

形成闭包的要件：

① 函数嵌套

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

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

def make_averager():# 创建一个列表，用来保存数值nums = []# 创建一个函数，用来计算平均值def averager(n) :# 将n添加到列表中nums.append(n)# 求平均值return sum(nums)/len(nums)return averageraverager = make_averager()print(averager(10))
print(averager(20))
print(averager(30))

1.7 装饰器

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

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

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

# 创建几个函数def add(a , b):'''求任意两个数的和'''r = a + breturn rdef mul(a , b):'''求任意两个数的积'''r = a * breturn rdef begin_end(old):'''用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束参数：old 要扩展的函数对象'''# 创建一个新函数def new_function(*args , **kwargs):print('开始执行~~~~')# 调用被扩展的函数result = old(*args , **kwargs)print('执行结束~~~~')# 返回函数的执行结果return result# 返回新函数return new_functionf2 = begin_end(add)
f3 = begin_end(mul)

向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()

2. 类和对象

2.1 对象

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

2.2 类

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

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

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

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

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

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

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

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

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

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

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

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

class MyClass():passmy = MyClass()
result = isinstance(my, MyClass)
print(result)
#输出为 true

---

# 尝试定义一个表示人的类
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)

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

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

2.4 创建对象的流程

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

2.5 封装

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

class MyClass:def __init__(self,name):self._name = namedef get_name(self):return self._namedef set_name(self, name):self._name = namedef hello(self):print("word")my = MyClass("chm")print(my.get_name())
my.set_name("yy")
print(my.get_name())
#输出：chm yy

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

隐藏属性：
可以为对象的属性使用双下划线开头，__xxx
双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问，其实隐藏属性只不过是Python自动为属性改了一个名字，实际上是将名字修改为了，_类名__属性名 比如 __name -> _Person__name使用__开头的属性，实际上依然可以在外部访问，所以这种方式我们一般不用
一般我们会将一些私有属性（不希望被外部访问的属性）以_开头

2.6 property装饰器

class MyClass:def __init__(self, age, name):self._age = ageself._name = name# property装饰器，用来将一个get方法，转换为对象的属性# 添加为property装饰器以后，我们就可以像调用属性一样使用get方法# 使用property装饰的方法，必须和属性名是一样的@propertydef age(self):return self._age# setter方法的装饰器：@属性名[e-mail] age(self, age):self._age = agemy = MyClass(22, "jj")
print(my.age)
my.age = 18
print(my.age)
#输出：22 18

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

2.7 继承

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

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

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

class Animal(object):def run(self):print("它会跑")def eat(self):print("它会吃")class Dog(Animal):passd = Dog()
d.run()
print(isinstance(d, Dog))
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))
print(issubclass(Animal, object))

输出为：

它会跑
True
True
True
True

继承在定义类时后加括号加入父类
所有类的父类都是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()

2.9 super()关键字

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

注意：

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

class Animal:def __init__(self,name):self._name = namedef run(self):print('动物会跑~~~')def sleep(self):print('动物睡觉~~~')@propertydef name(self):return [e-mail]    def name(self,name):self._name = name# 父类中的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法
class Dog(Animal):def __init__(self,name,age):# 希望可以直接调用父类的__init__来初始化父类中定义的属性# super() 可以用来获取当前类的父类，#   并且通过super()返回对象调用父类方法时，不需要传递selfsuper().__init__(name)self._age = agedef bark(self):print('汪汪汪~~~') def run(self):print('狗跑~~~~')   @propertydef age(self):return [e-mail]    def age(self,age):self._age = name        d = Dog('旺财',18) print(d.name)       
print(d.age)       

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

2.10 多重继承

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

class C(A,B):pass

2.11 多态

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

# 定义两个类
class A:def __init__(self, name):self._name = name@propertydef name(self):return [e-mail] name(self, name):self._name = nameclass B:def __init__(self, name):self._name = namedef __len__(self):return 10@propertydef name(self):return [e-mail] name(self, name):self._name = nameclass C:passa = A('孙悟空')
b = B('猪八戒')
c = C()# 定义一个函数--多态
# 对于say_hello()这个函数来说，只要对象中含有name属性，它就可以作为参数传递
#   这个函数并不会考虑对象的类型，只要有name属性即可
def say_hello(obj):print('你好 %s' % obj.name)

# 在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()来获取它的长度

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

2.12 类中的属性和方法总结

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

---

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

---

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

---

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

---

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

---

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

# 定义一个类
class A(object):# 1. 类属性，直接在类中定义的属性是类属性#   类属性可以通过类或类的实例访问到#   但是类属性只能通过类对象来修改，无法通过实例对象修改count = 0def __init__(self):# 2. 实例属性，通过实例对象添加的属性属于实例属性#   实例属性只能通过实例对象来访问和修改，类对象无法访问修改self.name = '孙悟空'# 3. 实例方法#   在类中定义，以self为第一个参数的方法都是实例方法#   实例方法在调用时，Python会将调用对象作为self传入  #   实例方法可以通过实例和类去调用#       当通过实例调用时，会自动将当前调用对象作为self传入#       当通过类调用时，不会自动传递self，此时我们必须手动传递selfdef test(self):print('这是test方法~~~ ' , self)    # 4. 类方法    # 在类内部使用 @classmethod 来修饰的方法属于类方法# 类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象#   类方法和实例方法的区别，实例方法的第一个参数是self，而类方法的第一个参数是cls#   类方法可以通过类去调用，也可以通过实例调用，没有区别@classmethoddef test_2(cls):print('这是test_2方法，他是一个类方法~~~ ',cls)print(cls.count)# 5. 静态方法# 在类中使用 @staticmethod 来修饰的方法属于静态方法  # 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例去调用  # 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数# 静态方法一般都是一些工具方法，和当前类无关@staticmethoddef 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()

2.13 特殊方法

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

# 定义一个Person类
class Person(object):"""人类"""def __init__(self, name, age):self.name = nameself.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 > otherdef __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,'还未成年了')

3. 模块

模块（module）
模块化，模块化指将一个完整的程序分解为一个一个小的模块通过将模块组合，来搭建出一个完整的程序
不采用模块化，统一将所有的代码编写到一个文件中
采用模块化，将程序分别编写到多个文件中模块化的有点：① 方便开发② 方便维护③ 模块可以复用！在Python中一个py文件就是一个模块，要想创建模块，实际上就是创建一个python文件
注意：模块名要符号标识符的规范在一个模块中引入外部模块
① import 模块名 （模块名，就是python文件的名字，注意不要py）
② import 模块名 as 模块别名- 可以引入同一个模块多次，但是模块的实例只会创建一个- import可以在程序的任意位置调用，但是一般情况下，import语句都会统一写在程序的开头- 在每一个模块内部都有一个__name__属性，通过这个属性可以获取到模块的名字- __name__属性值为 __main__的模块是主模块，一个程序中只会有一个主模块主模块就是我们直接通过 python 执行的模块

3.1 包 package

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

from hello import a , bprint(a.c)
print(b.d)

3.2 __pycache__文件夹

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

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

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')