Python自学笔记（万字）

Python基础语法

默认情况下，Python3源码文件以UTF-8编码，所有字符串都是Unicode字符串

注释

单行注释#井字符开头
多行注释可用多个#井字符，或者’''和"“”

#这是注释
'''
这是多行注释，第一行
第二行
'''

Python中使用缩进表示代码块，统一代码块需包含相同缩进空格数
可使用反斜杠实现多行语句

total=item_one+\
    item_two+\
    item_three

而在[]中括号，{}大括号或()小括号中的多行语句，不需要反斜杠\
反斜杠可以用来转义，使用r可以让反斜杠不发生转义，如r"this is a line with\n"则不发生转义，不显示为换行。
Python可以在同一行中使用多条语句，语句间用分号分割
import sys;x='runoob'
print默认输出为换行，如要实现不换行需在变量末尾加上end=“”，可含可不含空格，相应结果不同

x="a";y="b"
print(x,end=" ")
print(y,end=" ")

导入

• 将整个模块(somemodule)导入：import somemodule
• 从某个模块中导入某个函数；from somemodule import somefunction
• 从某个模块中导入多个函数：from somemodule import firstfunc,secondfunc
• 将某个模块中所有函数导入：from somemodule import *

字符串

字符串可以用+加号连接在一起，用*表示重复
Python字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
字符串截取的语法格式：变量[头下标:尾下标:步长]
print(str[1:5:2])输出从第二个开始到第六个且每隔一个字符
print(r'\n')输出\n
print(str[0:-1])输出第一个到倒数第二个字符
print(str[2:])输出从第三个开始的后面所有字符
截取格式：变量[头下标:尾下标]
索引值以0为开始值，-1为从末尾开始位置

从后面索引	-6	-5	-4	-3	-2	-1
从前面索引	0	1	2	3	4	5
	R	u	n	o	o	b
从前面截取	:	1	2	3	4	5
从后面截取	:	-5	-4	-3	-2	-1
无法向字符赋值，即向一个索引位置赋值word[0]='m'会报错

转义字符

换行符、制表符、换页符、响铃符等等。

字符串运算符

截取字符串中的一部分，[:]遵循左闭右开原则。
r/R——所有字符串都是直接按照字面意思使用，没有转义特殊或不能打印的字符。print(r'\n')输出\n
字符串格式化
基本用法是将一个值插入到一个有字符串格式符%s的字符串中。

三引号

三引号允许一个字符串跨多行。

字符串内建函数

基本数据类型

多个变量赋值
a=b=c=1
a,b,c=1,2,"runoob"

• 不可变数据：数字、字符串、元组
• 可变数据：列表、字典、集合(set)
  内置type()函数可以查询变量所指对象类型或isinstance()来判断

a=111
isinstance(a,int)
>>>True

type()不会认为子类是一种父类类型
isinstance()会认为子类是一种父类类型
bool是int的子类，True和False可以和数字相加
可以通过is判断类型

1 is True
>>>False

可以使用del删除变量
del var_a,var_b

数值计算

2/4#除法，得到浮点数
2//4#除法，得到一个整数
17%3#取余
2**5#乘方

Python数学类型

int(整型)、bool(布尔)、float(浮点型)、complex(复数):1+2j
Python中的单引号和双引号使用完全相同
复数表示形式：a+jb或complex(a,b)

• 数字以’0x’为开头，表示十六进制；
• 数字以’0o’为开头，表示八进制。

数学函数

需导入math库，并在使用函数时——math.XX

随机数函数

需导入random库，并在使用函数时——random.XX

三角函数

属于math库

数学常量

pi——π
e——自然常数

列表

写在[]方括号之间，用逗号分隔开
列表中的元素类型可以不同，列表也可作为元素
列表可以被索引和截取，列表被截取后返回一个包含所需元素的新列表
列表截取格式变量[头下标:尾下标]
列表中元素可改变，即可赋值
加号+为列表连接符，星号*为列表重复符
t=['a','b','c','d','e']
t[1:3]>>>['b','c']
t*2输出两次元素，但为一个列表
列表可正向索引，也可反向索引。

t[0]=9#赋值
t[2:5]=[13,14,15]#赋值
t[2:5]=[]#赋值

列表截取可以接收第三个参数——截取的步长
若第三个参数为负数，表示逆向读取
print(t[-1::-1])实现反转列表

• 第一个参数-1表示最后一个元素
• 第二个参数为空，表示移动到列表末尾
• 第三个参数为步长，-1表示逆向

实现翻转字符串

def reverseWords(input):
    inputwords=input.split(" ")
    inputwords=inputwords[-1::-1]
    output=' '.join(inputwords)#重新组合字符串
    return output

使用append()函数来添加列表项。list1.append(XXX)
使用del语句删除列表元素。del list[x]删除指定索引的列表项。

列表脚本操作符

len(list)——使用len()函数求出列表长度。
for x in [1,2,3]:print(x,end=' ')——迭代，输出1 2 3
3 in [1,2,3]——判断元素是否在列表中

嵌套列表

a=['a','b']
b=['c','d']
x=[a,b]
x
>>>[['a','b'],['c','d']]
x[0]
>>>['a','b']
x[0][1]
>>>b

列表比较

列表比较需要导入operator模块的eq方法

import operator
a=[1,2],b=[2,3]
print(operator.eq(a,b))

判断两列表是否相同，返回True或False。

列表函数&方法

len(list1)——列表元素个数
max(list1)——返回列表元素最大值
min(list1)——返回列表元素最小值
list(seq)——将元组转换为列表

方法	描述
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.pop(index=-1)	移除列表中的一个元素(默认最后一个元素)，并返回该元素值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reserve()	反向列表中元素
list.sort(key=None,reverse=None)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

元组(Tuple)

元组和列表类似，但元素不能修改，元组写在小括号中，用逗号隔开。
元素类型可以不同。
tuple=('abcd',123,2.23,'runoob')
索引，+连接，*重复
可以把字符串看作一种特殊的元组
虽然tuple元素不可变，但可以包含可变的元素，如List列表

tup1=()#空元组
tup2=(20,)#一个元素，需要在元素后面添加逗号

元组也可以被截取
元组的元素值不允许修改，但可以对元组进行连接组合。
使用del语句删除元组。del tup

可对元组的操作，与列表相类似，基本相同。
计算元素个数、连接、复制、判断元素是否存在、迭代

元组内置函数

参考列表的函数
tuple(iterable)——将可迭代系列转换为元组。

所谓的元组不可变性是指元组所指向的内存中的内容不可变。
重新赋值的元组，绑定到新的对象，并非修改了原来的对象。

集合(Set)

集合由一个或数个形态各异的大小整体组成，构成集合事物或对象称作元素或是成员
基本功能——成员关系测试和删除重复元素
可以使用大括号{}或set()函数创建集合
注：创建空集合必须使用set()而非{}，{}是用来创建空字典的
格式parame={valueoo,value01,value02,……}或set(value)
print(parame)输出集合时，重复的元素被自动去掉

#集合成员测试
if valuexx in parame:
    xxxxx
else:
    xxxxx
#集合运算
a=set('abraasd')#a输出为{'a','b',……}
b=set('qweqewasxzxc')
print(a-b)#a和b的差集
print(a|b)#a和b的并集
print(a&b)#a和b的交集
print(a^b)#a和b中不同时存在的元素

s.add(x)——将元素x添加到集合s中，若元素已存在，则不进行任何操作。
s.update(x)——也可添加元素，且参数可以是列表、元组、字典等。

集合函数

s.remove(x)或s.discard(x)——将元素x从集合s中移除
s.pop()——随机删除集合中的一个元素
len(s)——计算元素个数
s.clear()——清空集合
x in s——判断元素是否在集合中
集合内置方法见菜鸟教程

字典(Dictionary)

列表是有序对象集合，字典时无序对象集合
字典当中元素是通过键来存取的。
字典用{}标识，是无序的键:值集合
键(key)使用不可变类型

dict1={} #创建空字典
dict1=dict() #创建空字典
dict1['one']=……
dict1[2]=……

print(dict.keys())——输出字典所有键
print(dict.values())——输出字典所有值
构造函数dict()可以直接从键值对元组列表中构建字典
dict([('Runoob',1),('Google',2)])>>>{'Runoob':1,'Google':2}
{x:x**2 for x in (2,4,6)}>>>{2:4,4:16,6:36}
dict(Runoob=1,Google=2)>>>{'Runoob':1,'Google':2}
访问字典里的值——把相应的键放入到方括号中print(dict1[key1])
dict1[key1]=value_new——更新key1的值
dict1[key_new]=value——添加新的键值对
del dict1[key1]——删除键key1
dict1.clear()——清空字典
del dict1——删除字典

• 键必须不可变，可以用数字、字符串或元组充当，而用列表则不行。

字典内置函数&方法

len(dict)——计算字典元素个数，即键的总数
str(dict)——输出字典，可以打印的字符串表示

方法	描述
dict.clear()	删除字典内所有元素
dict.copy()	返回字典的浅复制
dict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key,default=None)	返回指定键的值，如果键不在字典中返回default设置的默认值
key in dict	如果键在字典中，返回true，否则返回false
dict.items()	以列表形式返回整个字典
dict.setdefault(key,default=None)	与get()类似，但如果键不存在与字典中，将添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.pop(key)	删除字典key所对应的值，返回被删除的值(key不可省略)
dict.popitem()	返回并删除字典中的最后一对键和值

Bytes类型

表示不可变的二进制序列
bytes类型中元素是整数值(0~255)，而非Unicode字符
通常用于处理二进制数据

创建bytes对象方式

• 使用b前缀
• 使用bytes()函数将其他类型转换为bytes类型

bytes对象处理方式

bytes()函数第一个参数是要转换的对象，第二个参数是编码方式。
若省略第二个参数，则默认使用UTF-8编码
x=bytes("hello",encoding="utf-8")
bytes类型支持切片、拼接、查找、替换等等。
由于bytes类型不可变，因此在修改操作时需创建一个新的bytes对象。

x=b"hello"
y=x[1:3]
z=x+b"world"
if x[0]==ord('h'):
    xxxxx

由于bytes类型元素是整数值，因此在比较时需要使用相应的整数值
ord()函数将字符转换为相应整数值

数据类型转换

隐式类型转换

Python会自动将一种数据类型转换为另一种数据类型

不同类型的数据进行运算

• 较低数据类型(int)自动转换为较高数据类型(float)，以免数据丢失。
• 整型和字符串类型运算无法进行隐式类型转换，会报错。

显式类型转换

使用int()、float()、str()等预定义函数来执行显式类型转换。

函数	描述
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex(x,y)	创建一个复数
str(x)	将x转换为字符串
ord(x)	将一个字符串转换为它的整数值
chr(x)	将一个整数转换为一个字符
tuple(x)、list(x)、set(x)	将x分别转换为元组、列表、可变集合
dict(x)	创建一个字典，x必须是(key,value)元组序列
bin(x)	转换为二进制
oct(x)	转换为八进制
hex(x)	转换为十六进制

运算符

赋值运算符

运算符	描述
+=	c+=a等效于c=c+a
:=	海象运算符，Python3.8新增运算符。海象运算符是特殊表达式，而不是赋值语句，有返回值。

海象运算符的返回值是等号右边表达式的值。

1. 海象运算符无法单独成为一行，会报错；
2. 无法单独被赋值语句使用。b=a:=2会报错，但b=(a:=2)不会报错。

-=、*=、/=、%=、**=、//=与加法赋值运算符使用一致。

位运算符

按位运算符是把数字看作二进制来进行计算。

运算符	描述
&	按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0
|	按位或运算符：只要对应的两个二进位有一个为1时，结果位就为1
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：对数据的每个二进制位取反，把1变为0，把0变为1。~x类似于-x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边数指定移动位数。高位丢弃，低位补0。
>>	右移动运算符：运算数的各二进位都右移若干位。

逻辑运算符

运算符	表达式	描述
and	x and y	布尔"与"——如果x是False，则返回x的值，否则返回y的计算值
or	x or y	布尔"或"——如果x是True，返回x的值，否则返回y的计算值
not	not x	布尔"非"——如果x是True，返回False；如果x是False，返回True

成员运算符

in——判断值是否在指定序列中；
not in——判断值是否不在指定序列中。

身份运算符

用于比较两个对象的存储单元

is——判断两个标识符是不是引用自一个对象；
is not——判断两个标识符是不是引用自不同对象。

is类似于id(),id()函数用于获取对象内存地址。

条件控制

if condition1:
    block1
elif condition2:
    block2
else:
    block3

if 嵌套

可以把if……elif……else结构放到另外一个if……elif……else结构中。

match……case

Python 3.10新增了match……case的条件判断。

match xxx:
    case condition1:
        block1
        break
    case condition2:
        block2
        break
    case _:
        block3
        break

case _:类似于c++中的default:，当其他case都无法匹配时，执行case _:后的内容。

循环语句

while 语句

while conditon:
    XXX
else:
    XXX

当condition为false时，执行else语句后面内容。
无限循环在服务器上客户端的实时请求非常有用。

for 语句

Python的for语句可以遍历任意可迭代对象，列表或字符串等。

for variable in sequence:
    XXX
else:
    XXX

for……else语句一般用于循环结束后执行一段代码。
若在循环过程中遇到break语句，则会中断循环，此时不会执行else语句。

• 可以遍历列表，并逐个输出列表元素；
• 也可遍历字符串，逐个打印字符串中的每个字符。
• 整数范围值可以配合range()函数使用for number in range(1,6)——左闭右开

for i in range(5)——0~4，生成数列
range(0,10,3)——可以指定步长，步长可以是负数。
range(-10,-100,-20)——步长为负数。
结合range()和len()函数遍历一个序列的索引。
list(range(5))——使用range()函数创建一个列表。
pass——pass语句是空语句，是为了保持结构的完整性，pass不做任何事情，一般用做占位语句。

推导式

Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

列表推导式

[out_exp_res for out_exp in input_list] #[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list if condition] #[表达式 for 变量 in 列表 if 条件]

• out_exp_res：列表生成元素的表达式，可以是有返回值的函数；
• for out_exp in input_list：迭代input_list将out_exp传入到out_exp__res表达式中；
• if condition：条件语句，可以过滤列表中不符合条件的值。

a=[i for i in range(30) if i%3==0]生成30以内可以被3整除的整数。

字典推导式

{key_expr: value_expr for value in collection} 
{key_expr: value_expr for value in collection if condition}

listdemo=['Google','Runoob','Taobao']
newdict={key:len(key) for key in listdemo} #将列表中各字符串值为键，各字符串的长度为值，组成键值对。

dic={x:x**2 for x in (2,4,6)}

集合推导式

{expression for item in Sequence}
{expression for item in Sequence if condition}

setnew=(i**2 for i in (1,2,3))

元组推导式

元组推导式可以利用range区间、元组、列表、字典和集合等数据类型，快速生成

(expression for item in Sequence)
(expression for item in Sequence if condition)

a=(x for x in range(1,10)) #a是一个生成器
tuple(a) #使用tuple()函数，可以直接将生成器对象转换成元组

元组推导式和列表推导式的用法完全相同，只是元组推导式是用()圆括号将各部分括起来，而列表推导式用的是中括号[]，另外元组推导式返回的结果是一个生成器对象。

迭代器

迭代是访问集合元素的一种方式。
迭代器是可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退。
迭代器两个基本的方法：iter()和next()
字符串，列表或元组对象都可用于创建迭代器。

list1=[1,2,3,,4]
it=iter(list1)
print(next(it))>>>1

for i in it:
    print(i)

创建一个迭代器

把一个类作为一个迭代器使用，需要在类中实现两个方法__iter__()和__next__()
__iter__()——返回一个特殊的迭代器对象，这个迭代器对象实现了__next__()方法并通过StopIteration异常标识迭代的完成。
__next__()——会返回下一个迭代器对象。

#创建一个返回数字的迭代器，初始值为1，步长为1
class MyNumber:
    def __iter__(self):
        self.a=1
        return self
    
    def __next__(self):
        x=self.a
        self.a+=1
        return x

myclass = MyNumber()
myiter=iter(myclass)

StopIteration

StopIeration异常用于标识迭代的完成，防止出现无限循环的情况，在__next__()方法中，可以设置在完成指定循环次数后触发StopIteration异常来结束迭代。

class MyNumber:
    def __iter__(self):
        self.a=1
        return self
    
    def __next__(self):
        if self.a<=20:
            x=self.a
            self.a+=1
            return x
        else:
            raise StopIteration

生成器

使用了yield的函数被称为生成器。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作。
在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield值，并在下一次执行next()方法时，从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
具体见菜鸟教程

函数

• 函数代码块以def关键词开头，后接函数标识符名称和圆括号()；
• 传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性地使用文档字符串用于函数说明
• 函数内容以冒号起始，并且缩进。
• return表达式结束函数，选择性地返回一个值给调用方，不带表达式的return相当于返回None。

def Hello():
    print('Hello, World!')
Hello()

def max(a,b):
    if a>b:
        return a
    else:
        return b

参数传递

在Python中。类型属于对象，对象有不同类型的区分，变量是没有类型的。
变量仅仅是一个对象的引用(一个指针)，可以指向列表类型对象，也可以指向字符串类型对象。

可更改与不可更改对象

string、tuple和number是不可更改对象，而list、dict等则是可以修改对象。
Python函数参数传递

• 不可变类型：类似C++的值传递。如整数、字符串、元组。fun(a)，传递的只是a的值，并没有影响对象a本身。如果在fun(a)内部修改a的值，则是新生成一个a的对象。
• 可变类型：类似C++的引用传递。如列表、字典。fun(a)，则是将真正的a传递进去，修改后，外部的a也会修改。

参数

必需参数

必需参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样。

关键字参数

函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明不同。

默认参数

函数调用时，如果没有传递参数，则会使用默认参数。

不定长参数

函数处理比声明时更多的参数。

def func(formal_variable,*var_tuple):
    XXX
    return XXX

加了*星号的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
如果在函数调用时没有指定参数，它就是一个空元组，也可以不向函数传递未命名的变量。

加了两个星号**的参数，会以字典的形式导入。
functiong2(1,a=2,b=3)

声明函数时，参数中星号可以单独出现。
如果单独出现星号，则星号后的参数必须用关键字传入

def f(a,b,*,c):
    return a+b+c
f(1,2,3) #会报错
f(1,2,c=3) #正常

匿名函数

Python使用lambda来创建匿名函数。
即不再使用def语句这样标准的形式定义一个函数。

• lambda只是一个表达式，函数比def简单很多
• lambda的主体是一个表达式，而不是一个代码块，仅仅能在Lambda表达式中封装有限的逻辑进去
• lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
• 虽然lambda函数看起来只能写一行，却不等同于C++中的内联函数。

lambda arg1,arg2,arg3: expression

x=lambda a:a+15
print(x(5))

sum=lambda arg1,arg2:arg1+arg2
print(sum(10,20))

可以将匿名函数封装在一个函数内，这样可以使用同样的代码创建多个匿名函数。

def func(n):
    return lambda a:n*a
x=func(2)
y=func(3)
print(x(11))
print(y(11))

数据结构

将列表当作堆栈使用

最先进入的元素最后一个被释放——后进先出。
用append()函数可以将一个元素添加到堆栈顶，用不指定索引的pop()函数可以把一个元素从堆栈顶释放出来。

将列表当作队列使用

在队列中第一加入的元素，第一个取出来。

拿列表当作队列使用效率不高，在列表最后添加或者弹出元素速度更快。

from collections import deque
queue=([1,2,3,4,5])
queue.append(6) #在列表末尾添加
queue.popleft() #从列表头部弹出

列表推导式

val=[2,4,6]
a=[3*x for x in val]
b=[[x,x**2] for x in val] #生成嵌套列表

嵌套列表解析

matrix=[
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
]
[[row[i] for row in matrix] for i in range(4)] #将3x4矩阵转换为4x3矩阵

transposed=[]
for i in range(4):
    transposed.append([row[i] for row in matrix])

del语句

使用del语句可以从一个列表中根据索引来删除一个元素，而不是值来删除元素。
可以用del语句从列表中删除一个切割，或清空整个列表。

del a[0] #删除列表第一个元素
del a[2:4] #删除列表第三和第四个元素
del a[:] #清空列表

遍历技巧

在字典中遍历时，关键字和对应的值可以使用items()方法同时解读出来。

dic={'a':1,'b':2,'c':3}
for k,v in dic.items():
    print(k,v)

在序列中遍历时，索引位置和对应值可以使用enumerate()函数同时得到：

for i,v in enumerate(['a','b','c']):
    print(i,v)

反向遍历一个序列，首先指定这个序列，然后调用reversed()函数：

for i in reversed(range(1,10,2)):
    print(i)

按顺序遍历一个序列，使用sorted()函数返回一个已排序的序列，并不修改原值：

basket=['apple','orange','pear','apple','banana']
for i in sorted(set(basket)):
    print(i)

模块

模块是一个包含所有定义的函数和变量的文件，后缀名为.py。模块可以被别的程序引入，以使用该模块中的函数等功能。
当导入某模块后，使用模块中的函数时，需要使用模块名称来访问函数。

如果经常使用某函数，可以给该函数赋给一个本地名称：fib=fibo.fib

from……import

Python的from语句从模块中导入一个指定的部分到当前命名空间中。
故使用函数时，不再需要通过模块名称访问，可直接访问。

from……import*

把一个模块的所有内容全部导入到当面命名空间中。

输入

读取键盘输入。

str1=input('请输入：')

面向对象

• 类：用来描述具有相同的属性和方法的对象的集合。定义了集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量。实例变量就是一个用self修饰的变量。

类

class ClassName:
    XXX
    XXX

类实例化后，可以使用其属性。创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。
属性引用语法：obj.name
类有一个名为__init__()构造方法，该方法在类实例化时会自动调用。

class Complex:
    def __init__(self,realpart,imagpart):
        self.r=realpart
        self.i=imagpart
x=Complex(3.0,-4.5)
print(x.r,x.i)

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例为self。

class Test:
    def prt(self):
        print(self)

self代表类的实例，代表当前对象的地址。
self不是Python关键字，换成runoob也是可以正常执行的。

类的方法

在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表类的实例。

继承

子类(派生类 DerivedClassName)会继承父类(基类 BaseClassName)的属性和方法。
class DerivedClassName(modname.BaseClassName):

class people:
    name=''
    age=0
    #定义私有属性，私有属性在类外部无法直接进行访问
    __weight=0
    def __init__(self,n,a):
        XXX
    def speak(self):
        XXX

class student(people):
    grade=''
    def __init__(self,n,a,g):
        people.__init__(self,n,a)
        #调用父类的构造函数
        self.grade=g
    #覆写父类的方法
    def speak(self):

类属性与方法

类的私有属性

__private:两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用self.__private

类的私有方法

__private_method:两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。

运算符重载

可以对类的专有方法进行重载。见菜鸟教程