python面向对象

1.class类

1.1定义类的基本用法

? class

? 在类里面叫方法，不是在类里面，叫函数（需要做以区分）

1.2类名命名规则

? 首字母大写，多个英文字母命名，字母首字母大写，大驼峰命名：如 WebDriver

1.3函数的作用域

user_name = ‘xiaoming‘

def user_info():
    print(user_name)			
    
user_info()			#调用方法，打印结果为‘xiaoming‘

user_name = ‘xiaoming‘

def user_info():
    user_name = ‘xiaohong‘
    print(user_name)			
    
user_info()			#调用方法，打印结果为‘xiaohong‘
print(user_name)	#打印结果为‘xiaoming‘

1.4类的调用：类的属性和方法的调用必须先实例化

user_name = ‘xiaoming‘

class Person:
    def user_info(self):         #定义方法
        print(user_name)

person = Person()                #类的调用，先实例化对象
person.user_info()               #调用方法,打印结果为‘xiaoming‘，与函数不一样，函数可以直接调用，类必须先实例化

user_name = ‘xiaoming‘

class Person:
    age = 18                     #类的属性，在类本身调用时，需要加self，即指向类本身
    def user_info(self):         #定义方法
        print(user_name, self.age)

person = Person()                #类的调用，先实例化对象
person.user_info()               #调用方法。打印结果为 ：xiaoming 18

print(person.age)                #可以通过实例化对象，来调用类的属性

person.age = 30					 #可以修改类属性的值
print(person.age)				 #类的属性和方法的调用，必须先实例化

class User:
    name = ‘xiaozhang‘
    age = 18                     #类的属性，在类本身调用时，需要加self，即指向类本身
    def user_info(self):         #定义方法
        print(self.name, self.age)

user = User()                    #类的调用，先实例化对象
user.user_info()                 #调用方法。打印结果为 ：xiaozhang 18

user.name = ‘xiaoli‘            #在外面可以改值，但是比较麻烦
user.age = 100
user.user_info()

1.5类的构造器

构造器 init 特殊方法，两个下划线

1.调用类的时候自动执行（不用实例化）

2.init中声明实例属性

3.一个类中可以创建多个方法，可以创建一个构造器。（创建多个也会被覆盖。相当于a = 1 ， a = 2， print(a)，打印结果 a = 2）

class User:
    def __init__(self):
        print(‘hello world‘)
        self.name = ‘xiaoming‘      #实例化的时候，创建name属性，和age属性
        self.age = 18

u = User()
print(u.age, u.name)

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

u = User(‘小李‘, 18)
print(u.name, u.age)         #self 指向类本身，打印结果：小李 18

方法B调用方法A，self.方法名

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

    def say_hello(self):
        print(f‘hello{self.name}‘)
    def say_all(self):
        self.say_hello()
user = User(‘张三‘, 18)
user.say_all()                      #打印结果：hello张三

1.6私有属性和方法

__变量

__方法

表示私有，只能在类中调用，不能在类的外部调用

在类的外部调用，会报错

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

    def __say_hello(self):
        print(f‘hello{self.name}‘)
    def say_all(self):
        self.__say_hello()
user = User(‘张三‘, 18)
user.say_all()                      #打印结果：hello张三
user.__say_hello()                  #报错:AttributeError: ‘User‘ object has no attribute ‘__say_hello‘

1.7类的继承

class 类名(父类类名)

子类默认拥有 父类的方法和属性

私有方法和私有属性不能在类的外部被调用（继承关系，私有属性和方法，也不会继承）====>私有方法只能在类的内部调用

可以继承一个父类，也可以继承多个父类

子类继承父类，子类继承父类的方法，也可以单独重写

class Animal:
    def __init__(self):
        self.name = ‘animal‘
    def run(self):
        print(‘动物会跑‘)
   
class Dog(Animal):     #继承Animal父类
    pass

dog = Dog()
dog.run()               #打印结果：动物会跑
print(dog.name)			#打印结果，animal

1.8一个下划线_

_跟普通方法一样

开发者之间有不成文的约定

_表示这个方法你可以调用，但是调用谨慎一些

class Animal:

    def _run(self):
        print(‘动物会跑‘)

class Dog(Animal):  # 继承Animal父类
    pass

dog = Dog()
dog._run()      # 打印结果：动物会跑

1.9模块

模块：一个python文件 就是一个模块

import 模块名 ====> import导入的时候，加载过程中，代码会先执行

导入模块

文件名：animal.py

class Animal:
    def run(self):
        print(‘动物会跑。。。‘)

文件名：test_animal

import animal                #导入animal模块（animal.py）

class Dog(animal.Animal):    #继承animal文件中Animal类
    pass

dog = Dog()
dog.run()                    #打印结果：动物会跑。。。

或者 from...import... (从模块中导入某一个类) ====> 两种写法都是可以的

form...import...,...

引入多个类，类之间用‘,‘隔开

from...import *

表示引入所有的

0from animal import Animal            #导入animal模块（animal.py）

class Dog(Animal):                   #继承animal文件中Animal类
    pass

dog = Dog()
dog.run()                            #打印结果：动物会跑。。。

1.10 main

一般用来调试本文件中的方法来做的。

本文件中，name 为 main

在其他文件运行，就是导入模块的名称

__name__  特殊变量

if __name__ == ‘__main__‘
		#只有本文件中执行的时候才会执行下面的语句

1.11包

包是指python文件夹

person为包

从包中导入 ====> 从导包的根目录路径导入的

? 每个python包中，都有一个 init .py文件

作用：引入包的时候会首先调用 init 文件中定义的操作（跟class里面，init的一样的）

from person.user import User

user = User()
user.say_hello()

python面向对象

原文：https://www.cnblogs.com/jonli/p/13200138.html