Python笔记（运算符、类和对象）

夏天的遥遥漓曦

已于 2022-12-28 20:54:47 修改

阅读量222

点赞数

分类专栏： Python 文章标签： python 开发语言

于 2022-11-26 10:13:28 首次发布

本文链接：https://blog.csdn.net/m0_73809176/article/details/128042837

版权

Python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、运算符

x.attribute 属性参考
x[index] 索引访问
x[index:index] 切片操作
:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。如：

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

1.算术运算符

+ - * / % ** //

2.比较运算符

>、<、<=、>=、！=、==

3.赋值运算符

=、+=、-=、%=、/=、//=、*=、**=、:=

4.位运算符

a = 0011 1100

b = 0000 1101  （二进制）（a为60，b为13）

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

5.逻辑运算符

or and not

6.成员运算符（成员测试）

in、not in

7.身份运算符(同一性测试）

is -- x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not -- x is not y ，类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

二、类和对象

类(Class):定义数据类型的数据（属性）和行为--函数（方法），代表一种事物的共同特点。

对象是类的具体实例（在Python语言中，类称为类对象；类的实例称为实例对象）

属性：实际上是在类中的变量，建议在类定义的开始位置初始化类属性，或者在构造函数（__init__()）中初始化实例属性

（成员）方法：类中定义的行为（函数）。

成员变量：类中定义的属性（变量）

对象object：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

1.创建类

类的声明格式如下：

class 类名：

类变量（类成员）

类的属性 #类的属性，即定义在类中的变量（成员变量）

类的行为 #类的行为，即定义在类中的函数（成员方法）

在类体中可以定义属于类的属性、行为

类名首字母一般要大写
类体中也可用pass语句

2.实例对象的创建和调用

基于类对象可以创建其实例对象，然后访问其方法或属性。语法：

创建类对象：anobject = 类名(参数列表) #参数列表可为空

调用：anobject.对象函数 或 anobject.对象属性

3.实例对象属性（变量）

通过“self.变量名”定义的属性称为实例对象属性（也称实例对象变量）。

实例对象属性在类的内部通过self访问，在外部通过对象实例（即anobject）访问

形式初始化：实例对象属性通过__init__()执行：（每个类都有）！！_两个下划线

self.实例变量名 = 初始值（初始值）

注：__init__()方法（即构造方法）必须包含self参数且该参数在第一个

在创建类对象时，会自动执行，同时将传入参数自动传递给__init__方法使用

然后，在其他实例函数中通过self访问：

self.实例变量名 = 值 #写入

self. 实例变量名 #读取

或者，在创建实例对象后，通过对象实例访问：

obj1 = 类名（） #创建实例对象

obj1.实例变量名 = 值 #写入

obj1.实例变量名 #读取

class Geese: 
    def __init__(self):   #注意要加def
        print("我是大雁类！")
wildGeese = Geese()  #>>我是大雁类！

4.类对象属性（类对象本身的变量）

在类体中形式初始化：类对象名 = 初始值

然后，在类定义的方法（即函数）中或外部代码中，通过类名访问：

类名.类变量名 = 值 #写入

类名.类变量名 #读取

5.方法（与类相关的函数）

声明格式：（第一个参数一般为self,必须填写）

def 方法名(self,[形参列表]):

函数体

self 的作用：

表示类对象本身的意思

在方法内部，想要访问类的成员变量，必须使用self

当我们使用类对象调用方法时，self会自动被Python传入

6.静态方法（与类的对象实例无关的方法）

在静态方法中访问对象实例会导致错误，通过装饰器@staticmethod来定义

声明格式：

@staticmethod

def 静态方法名([形参列表]):

函数体

调用格式：

类名.静态方法名([实参列表])

7.魔术方法

1）__str__ 字符串方法

返回值：字符串

2）__It__ 小于符号比较方法 --但可同时完成：小于符号和大于符号两种

传入参数：other --另一个类对象

返回值：True 或 False

如：

"""
class student:

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

stu1 = student("张三",11)
stu2 = student("李四",12)
print(stu1 < stu2)                       
#显示错误，因为不知道比较的是name，还是age"""

#正确格式：
class student:

    def init__(self,name,age):
        self.name = name
        self.age = age
    def __It__(self,other):
        return self.age < other.age

stu1 = student("张三",11)
stu2 = student("李四",12)
print(stu1 < stu2)                  #>>>True
print(stu1 > stu2)                  #>>>False

例：

class student:
    name = None      #学生名字
    age = None
    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")    #在成员方法中要访问成员变量，需要用 self.成员变量   
stu = student()           #在传入参数时可以忽略self
stu.name = "zhou"
stu.say_hi()                          #>>>Hi大家好，我是zhou

1.类和对象示例：定义类person，创建其对象，并调用对象方法

class person:                          #定义类person（注意：有冒号“：”）
    def sayhello(self):                 #定义类person的函数sayhello()
        print("hello,how are you?")
p = person()                           #创建对象
p.sayhello()                           #调用对象的方法

2.定义类对象属性

#类对象属性示例：
class person2:              #定义类person2
    count = 0                 #定义类对象属性（类变量）count，表示计数
    name = "person"           #定义属性name,表示名称

#测试代码
person2.count += 1          #通过类名访问，将计数加1
print(person2.count)        #通过类名访问，读取并显示类属性  >>1
print(person2.name)         #通过类名访问，读取并显示类属性  >>person
p1 = person2()              #创建实例对象1
p2 = person2()              #创建实例对象1
print((p1.name,p2.name))    #通过实例对象访问，读取成员变量的值>>("person","person")
person2.name = "雇员"        #通过类名访问，设置类属性值
print((p1.name,p2.name))    #读取成员变量的值 >>("雇员","雇员")

3.实例对象属性示例

class person3:
    name = None    #成员变量
    age = None

    def __init__(self,name,age):
        self.name = name       #初始化self.name，即成员变量name(第一个name) 
        self.age = age         #有初始化self.成员变量后，可以省略成员变量的定义
    def say_hi(self):          #定义类的函数
        print("您好，我叫",self.name)      #>>您好，我叫 张三
#测试代码
p1 = person3("张三",25)     #创建实例对象
p1.say_hi()                #调用对象函数
print(p1.age)              #>>25

8.封装

即将现实世界事物在类中描述为属性和方法

1).私有成员

部分属性和行为不公开对外开放，仅对内部使用

私有成员变量：变量名以__开头（2个下划线）

私有成员方法：方法名以__开头（2个下划线）

即完成私有成员的设置

只要在类中设置了私有的成员，私有方法无法直接被类对象使用，私有变量无法赋值，也无法获取值，

例：

#定义一个类：内含私有成员变量和私有成员方法
class Phone:
    __current_voltage = None         #当前手机运行电压
    def __keep_single_core(self):
        print("让CPU以单核模式运行")

phone = Phone()
phone.__keep_single_core()       #显示错误，私有成员方法无法被类对象直接使用
print(phone.__current_voltage)  #显示错误，私有成员变量无法被类对象直接使用

但可以被类内部其他的成员访问使用

#定义一个类：内含私有成员变量和私有成员方法
class Phone:
    __current_voltage = 1            #当前手机运行电压
    def __keep_single_core(self):    #保持单核模式
        print("让CPU以单核模式运行")

    def call_by_5g(self):            #5G通话
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")


phone = Phone()
phone.call_by_5g()

9.继承

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

class 子类名(父类名): #父类可以有一个或多个，（父类1，父类2，...）

类内容体

#类定义
class people:    #基类（父类）
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问,而在类方法中访问。 以两个下划线开头
    __weight = 0
    #定义构造方法
    def __init__(self,name,age,weight):
        self.name = name
        self.age = age
        self.__weight = weight
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))  
 
#单继承示例
class student(people):    #class 子类名(父类名1，[父类名2,...]):
    grade = ''
    def __init__(self,name,age,weight,grade):
        #调用父类的构函
        people.__init__(self,name,age,weight)
        self.grade = grade
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)   
s.speak()    #>>ken 说: 我 10 岁了，我在读 3 年级

10.类型注解（提示性，并非强制）

主要功能：

帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释（备注）

1）为变量设置类型注解：

变量：类型

如：

#基础数据类型注解（显示的变量定义，一眼就可以看出变量类型，一般无需注解）
var_1：int = 10
var_2: bool = True
var_3: str = "asdf"

#类对象类型注解（显示的变量定义，一眼就可以看出变量类型，一般无需注解）
class student:
    pass
stu:student = student()

#但是，无法直接看出变量类型时，会添加变量的类型注解
class student:
    pass
var_1: int = random.randint(1,10)
var_2: dict = json.loads(date)    
var_3: student = func()

#基础容器类型注解  （容器：列表，元组，字典，集合，字符串）
my_list: list = [1,2,3]
my_tuple: tuple = (1,2,3)
my_dict: dict = {1,2,3}
my_set: set = {1,2,3}
my_str: str = "qwer"

#容器类型详细注解
my_list: list[int] = [1,2,3]
my_tuple: tuple[str,int,bool] = ("qwer",222,True)  
 #!!!注意：元组类型设置类型详细注解，需要将每一个元素都标记出来
my_dict: dict[str,int] = {"asd":666}
#！！！注意：字典类型设置类型详细注解，需要2个类型，第一个是key，第二个是value,注意中间是冒号！！
my_set: set[int] = {1,2,3}

2）函数（方法）的类型注解- 形参注释

语法： def 函数方法名(形参名：类型，形参名：类型，......):

#对形参进行类型注解
def add(x:int,y:int):
    return x + y

同时，函数（方法）的返回值也是可以添加类型注解的，语法如下：

def 函数方法名(形参名：类型，形参名：类型，...，形参：类型) -> 返回值类型：

#对返回值进行类型注解
def func(data:list) -> list:
    return date

3）Union类型

Union[类型1，类型2，...] --多选一,要么类型1，要么类型2，...

#使用Union类型，必须先导包
from typing import Union
my_list: list[Union[int,str]] = [1,2,"qwe","asd"]
def func(date:Union[int,str]) -> Union[int,str]:
    pass
sunc()

11.多态

指多种状态，即完成某个行为时，使用不同的对象会得到不同的状态

常作用在继承关系上

"""抽象类：含有抽象方法的类称之为抽象类
抽象方法:方法体是空实现的（pass）称之为抽象方法
如下"""
class Animal:       
    def speak(self):
        pass

class Dog(Animal):          #继承父类Animal的一个子类Dog
    def speak(self):
        print("汪汪汪")

class Cat(Animal):         #继承
    def speak(self):
        print("喵喵喵")

def make_noise(animal:Animal):         #类型注解  def 方法名(形参名:类型)
    """制造点噪音，需要传入Animal对象"""
    animal.speak()

#演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)

12.访问限制

12.1 _foo （单下划线）：

以单下划线开头的表示protect（保护）类型的成员，只允许本身和子类进行访问，但不能使用“ from model import * ”语句导入。

class Swan:
    #天鹅类
    _neck_swan = "天鹅的脖子很长"    # 定义保护属性
    def __init__(self):
        print("__init__():",Swan._neck_swan)   # 在实例方法中访问保护属性
swan = Swan()
print("直接访问：",swan._neck_swan)    # 保护属性可以通过实例名访问
#>>__init__(): 天鹅的脖子很长
#>>直接访问： 天鹅的脖子很长

12.2 __foo （双下划线）

双下划线表示private（私有）类型的成员，只允许定义该方法的类本身进行访问，而且不能通过类的实例进行访问，但可通过“ 类的实例名.类名__xxx” 方式访问

class Swan:
    #天鹅类
    __neck_swan = "天鹅的脖子很长"    # 定义私有属性
    def __init__(self):
        print("__init__():",Swan.__neck_swan)   # 在实例方法中访问私有属性
swan = Swan()                       # 创建类的实例
print("加入类名：",swan._Swan__neck_swan)    # 私有属性 可通过“ 类的实例名.类名__xxx” 方式访问 >>__init__(): 天鹅的脖子很长
print("直接访问：",swan.__neck_swan)     # 私有属性不能通过类的实例进行访问,出错

12.3 foo :

首尾双下划线表示定义特殊方法，一般系统定义名字，如__init__()

13.创建用于计算的属性

@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。将方法转换为属性后，可以直接通过方法名来访问方法，不需要再加小括号（）

语法格式：

@property
def 方法名(self):
    方法体

方法名：一般使用小写字母开头，该名称最后将作为创建的属性名
方法名：通常以return语句结束，用于返回计算的结果

# 计算矩形面积
class Rect:
    def __init__(self, width, height):
        self.width = width   #self.实例变量名 = 值 #写入  self. 实例变量名 #读取
        self.height = height
    @property
    def area(self):
        return self.width * self.height
rect = Rect(800,600)
print("面积为：",rect.area)   #面积为： 480000   不需要再加小括号（）