Python高级语法之一

• 面向对象三大特点：封装、继承、多态；封装帮助完成对象并关注完成功能的结果。

  类名建议都用大驼峰（每个单词首字母都大写），方法一般小驼峰（第二个单词首字母大写）

方法就是把函数放类里参数加上self即可，如下：（对象通过类创建出来，创建对象的过程叫实例化。要有对象必须先创建类）

• 初始化方法 __init__(self,[形参]),在其内绑定初始属性，创建对象时自动调用。__str__(self) 方法返回一个字符对象，必须有返回

• 对象相关操作

dir(对象)  查看对象上有哪些属性和方法，可以查看list、dict、string上的方法，例如dir(‘111’)、dir(10)；

type() 获取对象的类型;

isinstance(对象，类型) 判断一个对象是否是指定类型，例如print(isinstance(11,int))

• 私有成员

__双下划线开头的私有属性在类外面无法访问

class Method():
    def __init__(self,name,age):
        self.name = name
        self.__age = age  # 私有方法，类外无法直接访问，只能通过下面的方法返回才能访问

    def getAge(self):
        return self.__age

m = Method('lcx',10)
print(m.name)
print(m.getAge())

print(m.__age)  #类直接访问类的私有属性，会报类没有该属性

 

输出如下:

Traceback (most recent call last):

  File "D:/script/pytest_yqyx/test/day1.py", line 16, in <module>

    print(m.__age)

AttributeError: 'Method' object has no attribute '__age'

lcx

10

 

• 类的继承

1、继承特点：

1.1、如没有任何父类继承，（）可以不写，如要写，写（object）

1.2、object为基础类，如没指定继承，默认自动继承该类

1.3、私有成员只能在本类中访问，子类不能继承和使用

 

2、多继承，一个类同时可以继承多个父类

class 类名（父类1,父类2…）:

       pass

3、  多层继承，子继承父亲且继承祖父

 

4、继承的重写（重点掌握）：子类中出现与父类相同的属性名或者方法名（当父类上的方法不能满足子类的要求时，但不能改父类代码，只能在子类重写父类的方法）

子类调用父类上的方法：super().父类方法名（[实参]）

多态：调用相同的方法，实现不同的功能

• 类属性及方法

1、类属性与实例属性：类属性是保存到类上的，所有对象都可共享； 实例属性是保存到，只有实例化后才能访问

1.1、类属性及实例属性的创建

class 类名(object):
    类属性名=值
    def __init__(self,name,age):
        self.实例属性名=值

类名.类属性名=值
1.2、类属性访问：类名.类属性名

2、类方法和静态方法

2.1、类方法：

2.1.1、类方法语法及调用

class 类名（object）:

        @classmethod

        def 类方法名（cls）:

               pass

调用（不用创建对象，直接类名调用）：类名.类方法名（[实际参数]）

2.1.2、类方法只能使用类上的属性和方法： 类名.类属性名（无需要实例化）；cls(class)代表的是类本身 cls.类属性名

举例如下：

2.2、静态方法：当方法中不使用类上的成员时，就定义为静态方法

2.1.1、静态方法语法及调用

class 类名（object）:

        @staticmethod

        def 静态方法名（）:

               pass

调用（不用创建对象，直接类名调用）：类名.静态方法名（[实际参数]）

举例如下：

 

3、了解__new__（开辟空间）方法：底层用于开辟对象空间的方法，所以优先于__init__（初始化属性）方法调用。该方法微调对象的创建过程。

语法：

class 类名（object）:

    def __new__(cls,[形参])：

         #开局内存空间

         super().__new__(cls)

    def __init__(self,[形参])：

         #绑定初始属性

备注：两方法的参数要一致。因为所以类都默认继承object,通过super().__new__(cls)就开辟了空间,最后将创建的对象返回

Class Student(object)：

Def __new__(cls,*args,**kwra):

    print(“改变空间”)

    super().__new(cls)

Def __init__(self,name,age):

    Self.name=name

    Self.age=age

Stu = Student(‘lcx’,20)

Print(stu)

单例模式

• 异常

异常：就是Python代码中的错误，如果出现错误 代码执行的时候 抛出异常，并且中断代码执行。错误不可避免，但应将错误捕获，让代码继续执行。现在我们看下如何捕获异常。

语法：

try:

    代码块,可能出错  

except [异常类型名1]:   #获取异常

    处理异常（打印，保存到文件;或继续抛出）

except [异常类型名2]:   #获取异常

    处理异常（打印，保存到文件;或继续抛出）

except （异常类型名3, 异常类型名4）:  #同时捕获类型3，4

    处理异常（打印，保存到文件;或继续抛出）

1、 异常的类型及捕获不同类型异常

1.1、    异常分不同类型 异常->类型->有不同的类组成->异常信息（对象）,举例如下：

print(aaa)  #NameError: name 'aaa' is not defined
open("lcx.txt") #AttributeError: 'NoneType' object has no attribute 'name'
li = [1,2,3]
print(li[111]) #IndexError: list index out of range

 

BaseException异常基类，所有异常都继承它。所有能捕获并让代码继续执行的错误，都是Exception类型或其子类型、系统错误类型可以捕获，但不建议捕获系统错误类型

 

#try里若有多行代码，其中一行出错后，其下的代码将不被执行；若指定错误类型，那只捕获指定的类型，下面只捕获NameError,FileNotFoundError

try:
    print(aaa)
    with open('./data.txt', 'r') as f:
        print(f.readlines())

except (NameError,FileNotFoundError):
    print('aaa打印出错，继续执行')
print(222)

 

1.1、  捕获所有类型的错误，except后不指定类型或指定为Exception即捕获所有类型

语法一：                   语法二：

try:                            try:

    代码块                     代码块

except：                   except Exception:

          异常处理                    异常处理

举例如下：

try:                                   try:

    print(aaa)                             print(aaa)

except:                                except Exception:

    print('aaa出错，继续执行')               print('aaa出错，继续执行')

print(222)                             print(222)

 

1.2、  获取系统提供的错误信息（异常对象）,except后加as

try:

    代码块,可能出错  

except 异常类型名1 as e :

    print(e)   

    处理异常（打印，保存到文件;或继续抛出）

except （异常类型名2, 异常类型名3）as e: 

    print(e)

          处理异常（打印，保存到文件;或继续抛出）

1.3、try…except的完整语法

try:

    代码块,可能出错  

except 异常类型名1 as e :

    print(e)   

    处理异常（打印，保存到文件;或继续抛出）

except （异常类型名2, 异常类型名3）as e: 

    print(e)

    处理异常（打印，保存到文件;或继续抛出）

else:

   无异常时执行这块

finally:

   这里都会执行

举例如下：

1.1、    raise将错误信息直接抛出；raise异常类名（“自定义错误信息”）自定义错误信息抛出，raise Exception(“自定义信息”)；下面分别举例：

       

• 模块及包

1、一个py文件就是一个模块，一次性导入模块所有内容 import 模块名；单独导入模块中的某个内容：from 模块名 import 类/函数/变量/*  *代表所有

限制导入模块的内容：__all__=[‘内容1’，‘内容2’……]  允许被导入的写到[]里面

 

1、 包：其实就是一个目录（文件夹）；为什么使用包：难免模块（文件）会重名。不同目录下的模块名可以重名。标准包下会有__init__.py文件，包的初始化文件。

2.1、包的导入两种方式：

import 模块名

import 包名.模块名

from 包名.模块名 import *

from 包名.模块名 import 类/函数/变量

from 包名 import 模块1，模块2

from 包名 import *   #导入该包下所有模块

 

直接通过包名导入所有模块后，使用会有错误提示，如下所示：

解决方法：需要在被导入包common下的初始化模块__init__第一行加入允许导入的模块名，如下所示：

魔术方法和魔术变量如下：

2.2、模块定位（重要）

#导入模块时：看模块的位置；若出 ModuleNotFoundError 错，解决方法
a、内建模块位置在python解释器里，随时导入使用。查看方式

import sys

print(sys.modules)

b、标准模块位置：在python安装目录下的Lib中，anaconda3\Lib 下所有模块，自带 随时导入可用，举例import os

import sys

c、自定义模块：放在主执行文件（python.ext）所在的当前目录下或其子目录下

d、第三方模块安装目录：anaconda3\Lib\site-packages

e、定义指定模块路径，用法

import sys

print(sys.path)

sys.path.append(“自定义路径”) #添加路径到列表的最后

sys.path.append(0,“自定义路径”) #添加路径到列表的开头

举例如下：

import sys
sys.path.append('D:\\script\\pytest_yqyx\\common')

print(sys.path)

2.3、解决模块出错

明确模块的查找顺序，按顺序排除错误：内建->标准->当前->第三方模块安装路径->自定义

• 给程序传参数、列表推导式（重点）、集合（set）、列表（list）、元组（tuple）

1、 给程序传参数

1.1、      程序所需要数据来源：外部录入、文件读取、给程序传递参数

Python.exe ./脚本.py  参数1  参数2……

 

1.2、      列表推导式（重要）：用于快速生成简单列表（可以进行简单的运算）

语法：[运算表达式 for i in 容器li1=[i for i in range(1,11)] #生成1-10的列表

li2 =[i**2 for i in range(1,11)] # 生成1-10 数的平方列表



li3 = [i for i in range(1,11,2)] #生成1-10中的奇数



li4 = [i for i in range(1,11) if i%2==0] #生成1-10中的偶数



name1 = ["name","age","sex"]

name2 = ["lcx",30,"f"]

dict1 = {a:b for a,b in zip(name1,name2)} #将两个列表合成字典



dict2 = {chr(a):random.randint(1,30) for a in range(97,102)} #生成Key是从a到e，value是1-30中任意数的字典



li5 = list(range(1,15))

li6 = [li5[i:i+3] for i in range(0,len(li5),3)]  #把列表里的元素分组,3个一组



print('li1:%s' %li1)

print('li2:%s' %li2)

print('li3:%s' %li3)

print('li4:%s' %li4)

print('li6:%s' %li6)

print('dict1:%s' %dict1)

print('dict2:%s' %dict2)

输出结果如下：

li1:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

li2:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

li3:[1, 3, 5, 7, 9]

li4:[2, 4, 6, 8, 10]

li6:[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14]]

dict1:{'name': 'lcx', 'age': 30, 'sex': 'f'}

dict2:{'a': 17, 'b': 26, 'c': 21, 'd': 7, 'e': 5}

 

1.3、      集合的特殊用法

数据类型之间可以相互转换

& 交集 a&b

|   并集 a|b

-       差补;==等于;!=不等于；in属于；not in 不属于

 

# 取上面两个列表的交集（先转换成元组，取交集后再转换成列表）
list = list(set(li1) & set(li2))
print(list)

 

• 阶段总结：

面向对象的三大特征是？

答：封闭、继承、多态

简述类的作用？类中可以有什么？

答：类用来描述现实生活中的事物。类中可以有方法属性（添加：类里面，方法外面；类名.属性名），类属性、实例属性（添加 对象.属性名；self.属性名）。初始方法、实例方法(通过实例调用)、类方法（@@classmethod,第一个参数cls），静态方法(@staticmethod)；类方法和静态方法通过类名直接调用。

简述__init__,__new__的作用及调用时机？

答：__init__ 绑定初始属性；__new__开辟实例空间

什么是私有成员？私有成员的好处？

答：双下划线开头为么有成员；好处对私有成员的保护作用。

什么继承？继承的分类？

答：具有从属关系的类，子类继承父类；单 继承，多层继承，多继承

什么是重写？通过一段代码阐明

答：子类中有跟父类中相同的属性名或方法名；父类不具备子类的功能才会重写

什么是实例属性和类属性？类属性的特点及访问方式。

答：对象上绑定属性为实例属性。类属性所有对象共享。通过类名直接访问。

什么是静态方法和类方法？写一段代码

写一个简单的模式

异常的完整语法？

try:

…

except:

   …

else:

   …

finally:

   …

如何抛出异常？

答：Raise 或raise 异常名（“自定义信息，可无”）

什么是模块？什么是包？

包：带__init__.py模块的文件夹；模块：包下的.py文件

导入模块和包的方式有哪些？

模块的定位方式？

答：5种

写出一段Python代码实现删除一个List里面的重复元素

List1 = [1,2,3,4,2,3]

L=list(set(List1))

快速获取1-100中的奇数

[ i for i in range(1,101,2)]