<jupyter_start><jupyter_text>模块（Module） 模块：一个py文件就是一个模块，里面包含定义的类，函数，变量等1-一个模块只会被导入一次，无论import多少次，以防止已导入的模块被重复执行2-模块除了定义方法外，还包括可执行代码。这些代码用于初始化模块，并且只在第一次导入时被执行3-每个模块都有 name 属性，当值为 main 时，表示该模块自身在运行，否是是被导入 包:一种管理 Python 模块命名空间的形式，采用"点模块名称"。1 一个模块的名称是 A.B表示一个包 A中的子模块 B 。2 目录只有包含一个叫做   __init__   .py 的文件才会被认作是一个包  面向对象 面向对象的四大特征：封装、继承、多态、抽象封装：将对象的属性和方法结合为一个整体，并尽可能隐蔽对象内部实现细节，只公开我提供的功能继承：从已有的类别派生出新的类称为子类，子类可以继承父类的属性和方法，同时可以扩展自己的方法多态：同一方法可以根据调用对象的不同而采用多种不同的方法抽象：从众多事物中抽取共同属性和方法的过程  类定义 方法和属性类型：公有、私有、保护、静态1-方法&nbsp; 1.1   __init__ ()是类的构造函数&nbsp; 1.2 类方法的第一个参数是'self',用于指向实例&nbsp; 1.3 public方法：没有下划线；protected方法：一个下划线 ；private方法：两个下划线&nbsp; 1.4 类的静态方法需要加 @staticmethod ,同时去掉self2-属性&nbsp; 2.1 实例属性：在 __init__ ()中初始化，使用slef调用&nbsp; 2.2 类属性：在   __init__ ()中初始化，使用类名调用<jupyter_code>class Student:
    #类属性（静态变量）
    number=0
    
    def __init__(self,name,age,score):
        #实例属性
        self.name=name
        self.age=age
        #私有属性
        self.__socre=score
        #类属性
        Student.number+=1
        
    #公有方法
    def print_info(self):
        print('Name is {} and age is {}'.format(self.name,self.age))
        self.__print_score()
    
    #私有方法
    def __print_score(self):
        print('Socre is {}'.format(self.__socre))
        
    #类方法（静态方法）
    @staticmethod
    def print_student_num():
        print('The number of student is {}'.format(Student.number))

#实例方法和属性
s1=Student('Tom',10,88.5)
s1.print_info()
print(s1.name)

#类方法和类属性
Student.print_student_num()
print(Student.number)<jupyter_output>Name is Tom and age is 10
Socre is 88.5
Tom
The number of student is 1
1<jupyter_text>继承&多态<jupyter_code>#在Python中是允许多继承
class Animal:
    def print_info(self):
        print('This is animal')
        
        
class Dog(Animal):
    def print_info(self):
        print('This is dog')
        
class Cat(Animal):
    def print_info(self):
        print('This is cat')

def animal_info(obj):
    obj.print_info()
    
d=Dog()
c=Cat()

animal_info(c)
animal_info(d)<jupyter_output>This is cat
This is dog<jupyter_text>抽象 1 在python中，我们不以有无执行体来区分是否是抽象类，而是根据是否有@abc.abstractmethod装饰器作为标准2 抽象类是一个特殊的类，只能被继承，不能实例化<jupyter_code>import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def print_info(self):
        pass
    
class Tigger(Animal):
    def print_info(self):
        print('This is tigger')

t=Tigger()
t.print_info()<jupyter_output>This is tigger<jupyter_text>类的专有方法<jupyter_code>__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方<jupyter_output><empty_output><jupyter_text>运算符重载<jupyter_code>class Vector:
    def __init__(self,a,b):
        self.a=a
        self.b=b
    
    def __repr__(self):
        return 'Vector({},{})'.format(self.a,self.b)
    
    def __add__(self,other):
        return Vector(self.a+other.a,self.b+other.b)
    
v1=Vector(1,2)
v2=Vector(3,4)
v3=v1+v2
print(v3)<jupyter_output>Vector(4,6)<jupyter_text>断言（Assert） 1 assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常2 assert expression 等价于  if not expression:  raise AssertionError a=2b=3assert 表达式，异常信息assert a==b,'a不等于b'<jupyter_code>import sys
#不会抛出异常
assert ('win32' in sys.platform), "该代码只能在 windows 下执行"
#抛出指定异常信息
assert ('linux' in sys.platform), "该代码只能在 Linux 下执行"<jupyter_output><empty_output><jupyter_text>异常 1-运行期检测到的错误被称为异常2-异常捕捉可以使用 try/except 语句  异常处理<jupyter_code>try:
    x=1/0
except ZeroDivisionError as err:
    print('运输时的异常信息：',err)
finally:
    print('是否发生异常都会进入finally')<jupyter_output>运输时的异常信息： division by zero
是否发生异常都会进入finally<jupyter_text>抛出异常<jupyter_code>def legal_age(age):
    if age<18:
        raise Exception('年龄低于18岁')
    else:
        print('年龄合法')

legal_age(17)<jupyter_output><empty_output><jupyter_text>自定义异常<jupyter_code>class MyException(Exception):
    def __init__(self,message):
        self.message=message
        
    def __repr__(self):
        return self.message
    
try:
    raise MyException('My test exception')
except MyException as err:
    print(err)<jupyter_output>My test exception
{'fraction_non_alphanumeric': 0.11597004107272288, 'fraction_numerical': 0.015945880647499397, 'mean_word_length': 4.461741424802111, 'pattern_counts': {'":': 0, '<': 32, '<?xml version=': 0, '>': 31, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '422568', 'license': 'MIT', 'n_tokens_mistral': 2158, 'n_tokens_neox': 2328, 'n_words': 278, 'path': 'part_3/python_grammar_03.ipynb', 'repo_name': 'whyAndBetter/python_grammar', 'size': '4139'}