Python学习笔记（自用）

艾卡西亚暴雨o

已于 2023-08-24 10:47:56 修改

阅读量1.3k

点赞数 1

文章标签：学习

于 2022-03-08 19:29:38 首次发布

本文链接：https://blog.csdn.net/m0_64735594/article/details/123360547

版权

一、整数

divmod()函数可以同时得到商和余数，返回的是一个元组。

round（value）：可以返回四舍五入的值

返回当前时间： import time

time.time(),但是计算机的时间是从1970年1月1日0：00：00开始返回值是秒的浮点数。

二、字符串：

8位的ASCLL码是16位的Unicode子集

转义字符： \续行符 \\反斜杠符 \'单引号 \"双引号 \b退格 \n换行 \t横向制表符 \r回车

不换行打印：print("aa",end=' ') . 默认换行符结尾。

生成一个新字符串，不会改变原字符串

#slice字符串切片操作 [起始偏移量start:终止偏移量end:步长step]

split()分割和join()合并

a.capitalize()产生新字符串，首字母大写 a.title()每个单词首字母大写

a.upper()所有字母大写 a.lower()全部转为小写

a.swapcase()大小写转换. a.center()居中等方法可以随用随学。

format格式化

可变字符串

需要原地修改字符串，可以使用io.StringIO 对象或array 模块。

>>> import io
>>> s = "hello, sxt"
>>> sio = io.StringIO(s)              #可变字符串
>>> sio
<_io.StringIO object at 0x02F462B0>
>>> sio.getvalue()                    #获取字符串的值
'hello, sxt'
>>> sio.seek(7)                       #指针移动到修改的位置(0开始)
7
>>> sio.write("g")                    #改为g
1
>>> sio.getvalue()
'hello, gxt'

三、列表

range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：

range([start,] end [,step])

start 参数：可选，表示起始数字。默认是 0

end 参数：必选，表示结尾数字。

step 参数：可选，表示步长，默认为 1

python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其

转换成列表对象。

>>> list(range(3,15,2))

[3, 5, 7, 9, 11, 13]

>>> list(range(15,3,-1))

[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

>>> list(range(3,-10,-1))

[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

append()方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。

>>> a = [20,40]

>>> a.append(80)

>>> a

[20, 40, 80]

extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

>>> a = [20,40]

>>> id(a)

46016072

>>> a.extend([50,60])

>>> id(a)

46016072

insert()插入元素

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后

面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种

移动的函数还有：

remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后

面元素的移动。

>>> a = [10,20,30]

>>> a.insert(2,100)

>>> a

[10, 20, 100, 30]

pop()方法

pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

>>> a = [10,20,30,40,50]

>>> a.pop()

50

>>> a

[10, 20, 30, 40]

>>> a.pop(1)

20

>>> a

[10, 30, 40]

remove()方法

删除首次出现的指定元素，若不存在该元素抛出异常。

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a.remove(20)

>>> a

[10, 30, 40, 50, 20, 30, 20, 30]

>>> a.remove(100)

Traceback (most recent call last):

File "<pyshell#208>", line 1, in <module>

a.remove(100)

ValueError: list.remove(x): x not in list

index()获得指定元素在列表中首次出现的索引

index()可以获取指定元素首次出现的索引位置。语法是：

index(value,[start,[end]])。其中，start 和 end 指定了搜索的范围。

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a.index(20)

1

>>> a.index(20,3)

5

>>> a.index(20,3)

#从索引位置 3 开始往后搜索的第一个 20

5

>>> a.index(30,5,7) #从索引位置 5 到 7 这个区间，第一次出现 30 元素的位置

6

count()获得指定元素在列表中出现的次数

count()可以返回指定元素在列表中出现的次数。

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a.count(20)

3

len()返回列表长度

len()返回列表长度，即列表中包含元素的个数。

>>> a = [10,20,30]

>>> len(a)

3

切片操作

切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：

[起始偏移量 start:终止偏移量 end[:步长 step]]

我们可以通过如下简单方式，实现列表元素内容的复制：

list1 = [30,40,50]

list2 = [] + list1

建新列表的排序

我们也可以通过内置函数 sorted()进行排序，这个方法返回新列表，不对原列表做修改。

>>> a = [20,10,30,40]

>>> id(a)

46016008

>>> a = sorted(a)

#默认升序

>>> a

[10, 20, 30, 40]

>>> id(a)

45907848

>>> a = [20,10,30,40]

>>> id(a)

45840584

>>> b = sorted(a)

>>> b

[10, 20, 30, 40]

>>> id(a)

45840584

>>> id(b)

46016072

>>> c = sorted(a,reverse=True)

#降序

>>> c

[40, 30, 20, 10]

reversed()返回迭代器

内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数

reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

>>> a = [20,10,30,40]

>>> c = reversed(a)

>>> c

<list_reverseiterator object at 0x0000000002BCCEB8>

>>> list(c)

[40, 30, 10, 20]

>>> list(c)

[]

我们打印输出 c 发现提示是：

list_reverseiterator。也就是一个迭代对象。同时，我们使用list(c)进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。

四、元组 tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的

元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

总结：

tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。

list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

>>> a = (20,10,30,9,8)

>>> sorted(a)

[8, 9, 10, 20, 30]

zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

>>> a = [10,20,30]

>>> b = [40,50,60]

>>> c = [70,80,90]

>>> d = zip(a,b,c)

>>> list(d)

[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推

导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()

方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如

果需要重新访问其中的元素，必须重新创建该生成器对象。

>>> s = (x*2 for x in range(5))

>>> s

<generator object <genexpr> at 0x0000000002BDEB48>

>>> tuple(s)

(0, 2, 4, 6, 8)

>>> list(s)

#只能访问一次元素。第二次就为空了。需要再生成一次

[]

>>> s

<generator object <genexpr> at 0x0000000002BDEB48>

>>> tuple(s)

()

>>> s = (x*2 for x in range(5))

>>> s.__next__()

0

>>> s.__next__()

2

>>> s.__next__()

4

元组总结

1. 元组的核心特点是：不可变序列。

2. 元组的访问和处理速度比列表快。

3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

五、字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。 “值”可以是任意的数据，并且可重复。

字典的创建

1. 我们可以通过{}、dict()来创建字典对象。

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}

>>> b = dict(name='gaoqi',age=18,job='programmer')

>>> a = dict([("name","gaoqi"),("age",18)])

>>> c = {}

#空的字典对象

>>> d = dict()

#空的字典对象

2. 通过 zip()创建字典对象

>>> k = ['name','age','job']

>>> v = ['gaoqi',18,'techer']

>>> d = dict(zip(k,v))

>>> d

{'name': 'gaoqi', 'age': 18, 'job': 'techer'}

3. 通过 fromkeys 创建值为空的字典

>>> a = dict.fromkeys(['name','age','job'])

>>> a

{'name': None, 'age': None, 'job': None}

字典元素的访问

为了测试各种访问方法，我们这里设定一个字典对象：

a = {'name':'gaoqi','age':18,'job':'programmer'}

1. 通过 [键] 获得“值”。若键不存在，则抛出异常。

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}

>>> a['name']

'gaoqi'

>>> a['age']

18

>>> a['sex']

Traceback (most recent call last):

File "<pyshell#374>", line 1, in <module>

a['sex']

KeyError: 'sex'

2. 通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设

定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。

>>> a.get('name')

'gaoqi'

>>> a.get('sex')

>>> a.get('sex','一个男人')

'一个男人'

3. 列出所有的键值对

>>> a.items()

dict_items([('name', 'gaoqi'), ('age', 18), ('job', 'programmer')])

4. 列出所有的键，列出所有的值

>>> a.keys()

dict_keys(['name', 'age', 'job'])

>>> a.values()

dict_values(['gaoqi', 18, 'programmer'])

5. len() 键值对的个数

6. 检测一个“键”是否在字典中

>>> a = {"name":"gaoqi","age":18}

>>> "name" in a

True

六、集合

集合创建和删除

1. 使用{}创建集合对象，并使用 add()方法添加元素

>>> a = {3,5,7}

>>> a

{3, 5, 7}

>>> a.add(9)

>>> a

{9, 3, 5, 7}

2. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保

留一个。

>>> a = ['a','b','c','b']

>>> b = set(a)

>>> b

{'b', 'a', 'c'}

3. remove()删除指定元素；clear()清空整个集合

>>> a = {10,20,30,40,50}

>>> a.remove(20)

>>> a

{10, 50, 30}

七、控制语句

三元条件运算符

Python 提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如

下：条件为真时的值 if (条件表达式) else 条件为假时的值

上一个案例代码，可以用三元条件运算符实现：

num = input("请输入一个数字")

print( num if int(num)<10 else "数字太大")

可以看到，这种写法更加简洁，易读

【操作】已知点的坐标(x,y)，判断其所在的象限

x = int(input("请输入 x 坐标")) 
y = int(input("请输入 y 坐标")) 
if(x==0 and y==0):
    print("原点") 
elif(x==0):
    print("y 轴") 
elif(y==0):
    print("x 轴") 
elif(x>0 and y>0):
    print("第一象限") 
elif(x<0 and y>0):
    print("第二象限") 
elif(x<0 and y<0):
    print("第三象限") 
else:
    print("第四象限")

选择结构嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了

代码的从属关系。

【操作】输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60 以上是 D。60 以下是 E。

score = int(input("请输入一个在 0-100 之间的数字：")) 
grade = "" 
if score>100 or score<0: 
    score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) 
else:if score>=90: 
    grade = "A" 
elif score>=80: 
    grade = 'B' 
elif score>=70: 
    grade = 'C' 
elif score>=60: 
    grade = 'D' 
else:
    grade = 'E' 
print("分数为{0},等级为{1}".format(score,grade))

循环结构

while 循环

【操作】利用 while 循环打印从 0-10 的数字。

num = 0

while num<=10:

print(num)

num += 1

for 循环和可迭代对象遍历

可迭代对象

Python 包含以下几种可迭代对象：

1. 序列。包含：字符串、列表、元组

2. 字典

3. 迭代器对象（

iterator）

4. 生成器函数（generator）

5. 文件对象

嵌套循环和综合练习

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

【操作】打印如下图案

for x in range(5): 
    for y in range(5): 
        print(x,end="\t") 
    print() #仅用于换行

【操作】利用嵌套循环打印九九乘法表

for m in range(1,10): 
    for n in range(1,m+1): 
        print("{0}*{1}={2}".format(m,n,(m*n)),end="\t") 
    print()

break 语句

break 语句可用于 while 和 for 循环，用来结束整个循环。当有嵌套循环时，break 语句只

能跳出最近一层的循环。

【操作】使用 break 语句结束循环

while True: 
    a = input("请输入一个字符（输入 Q 或 q 结束）") 
    if a.upper()=='Q': 
        print("循环结束，退出") 
        break 
    else:
        print(a)

continue 语句

continue语句用于结束本次循环，继续下一次。多个循环嵌套时,也是应用于最近的一层循环。

循环代码优化

虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

1. 尽量减少循环内部不必要的计算

2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。

3. 局部变量查询较快，尽量使用局部变量

其他优化手段

1. 连接多个字符串，使用 join()而不使用+

2. 列表进行元素插入和删除，尽量在列表尾部操作

使用 zip()并行迭代

我们可以通过 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。

【操作】测试 zip()并行迭代

八、函数

函数是可重用的程序代码块。函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。一致性指的是，只要修改函数的代码，则所有调用该函数的地方都能得到体现。在编写函数时，函数体中的代码写法和我们前面讲述的基本一致，只是对代码实现了封装，并增加了函数调用、传递参数、返回计算结果等内容。为了让大家更容易理解，掌握的更深刻。我们也要深入内存底层进行分析。绝大多数语言内存底层都是高度相似的，这样大家掌握了这些内容也便于以后学习其他语言。

函数的基本概念

1. 一个程序由一个个任务组成；函数就是代表一个任务或者一个功能。

2. 函数是代码复用的通用机制。

Python 中函数分为如下几类：

1. 内置函数

我们前面使用的 str()、list()、len()等这些都是内置函数，我们可以拿来直接使用。

2. 标准库函数

我们可以通过 import 语句导入库，然后使用其中定义的函数

3. 第三方库函数

Python 社区也提供了很多高质量的库。下载安装这些库后，也是通过 import 语句导

入，然后可以使用这些第三方库的函数

4. 用户自定义函数

用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。今天我们学习的

就是如何自定义函数。

Python 中，定义函数的语法如下：

def 函数名 ([参数列表]) :

'''文档字符串'''

函数体/若干语句

要点：

1. 我们使用 def 来定义函数，然后就是一个空格和函数名称；

(1) Python 执行 def 时，会创建一个函数对象，并绑定到函数名变量上。

2. 参数列表

(1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开

(2) 形式参数不需要声明类型，也不需要指定函数返回值类型

(3) 无参数，也必须保留空的圆括号

(4) 实参列表必须与形参列表一一对应

3. return 返回值

(1) 如果函数体中包含 return 语句，则结束函数执行并返回值；

(2) 如果函数体中不包含 return 语句，则返回 None 值。

4. 调用函数之前，必须要先定义函数，即先调用 def 创建函数对象

(1) 内置函数对象会自动创建

(2) 标准库和第三方库函数，通过 import 导入模块时，会执行模块中的 def 语句

浅拷贝和深拷贝

为了更深入的了解参数传递的底层原理，我们需要讲解一下“浅拷贝和深拷贝”。我们可以

使用内置函数：copy(浅拷贝)、deepcopy(深拷贝)。

浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用。

深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

#测试浅拷贝和深拷贝

import copy

def testCopy():

'''测试浅拷贝'''

a = [ 10 , 20 , [ 5 , 6 ]]

b = copy.copy(a)

print ( "a" , a)

print ( "b" , b)

b.append( 30 )

b[ 2 ].append( 7 )

print ( "浅拷贝......" )

print ( "a" , a)

print ( "b" , b)

def testDeepCopy():

'''测试深拷贝'''

a = [ 10 , 20 , [ 5 , 6 ]]

b = copy.deepcopy(a)

print ( "a" , a)

print ( "b" , b)

b.append( 30 )

b[ 2 ].append( 7 )

print ( "深拷贝......" )

print ( "a" , a)

print ( "b" , b)

testCopy()

print ( "*************" )

testDeepCopy()

运行结果：

a [10, 20, [5, 6]]

b [10, 20, [5, 6]]

浅拷贝......

a [10, 20, [5, 6, 7]]

b [10, 20, [5, 6, 7], 30]

*************

a [10, 20, [5, 6]]

b [10, 20, [5, 6]]

深拷贝......

a [10, 20, [5, 6]]

b [10, 20, [5, 6, 7], 30]

参数的几种类型

位置参数

函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为：

“位置参数”。

默认值参数

我们可以为某些参数设置默认值，这样这些参数在传递时就是可选的。称为“默认值参数”。

默认值参数放到位置参数后面。

执行结果：

8 9 10 20

8 9 19 20

8 9 19 29

命名参数

我们也可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”。

可变参数

可变参数指的是“可变数量的参数”。分两种情况：

1. *param（一个星号），将多个参数收集到一个“元组”对象中。

2. **param（两个星号），将多个参数收集到一个“字典”对象中。

【操作】测试可变参数处理（元组、字典两种方式）

def f1(a,b,*c):

print(a,b,c)

f1(8,9,19,20)

def f2(a,b,**c):

print(a,b,c)

f2(8,9,name='gaoqi',age=18)

def f3(a,b,*c,**d):

print(a,b,c,d)

f3(8,9,20,30,name='gaoqi',age=18)

执行结果：

8 9 (19, 20)

8 9 {'name': 'gaoqi', 'age': 18}

8 9 (20, 30) {'name': 'gaoqi', 'age': 18}

执行结果：

8 9 (19, 20)

8 9 {'name': 'gaoqi', 'age': 18}

8 9 (20, 30) {'name': 'gaoqi', 'age': 18}

强制命名参数

在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”。

def f1(*a,b,c):

print(a,b,c)

#f1(2,3,4)

#会报错。由于 a 是可变参数，将 2,3,4 全部收集。造成 b 和 c 没有赋值。

f1(2,b=3,c=4)

执行结果：

(2,) 3 4

lambda 表达式和匿名函数

lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数

的方法。lambda 函数实际生成了一个函数对象。

lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数

的返回值。

lambda 表达式的基本语法如下：

lambda arg1,arg2,arg3... : <表达式>

arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。

eval()函数

功能：将字符串 str 当成有效的表达式来求值并返回计算结果。

语法： eval(source[, globals[, locals]]) -> value

参数：

source：一个 Python 表达式或函数 compile()返回的代码对象

globals：可选。必须是 dictionary

locals：可选。任意映射对象

#测试 eval()函数

s = "print('abcde')"

eval (s)

a = 10

b = 20

c = eval ( "a+b" )

print (c)

dict1 = dict ( a = 100 , b = 200 )

d = eval ( "a+b" ,dict1)

print (d)

eval 函数会将字符串当做语句来执行，因此会被注入安全隐患。比如：字符串中含有删除文

件的语句。那就麻烦大了。因此，使用时候，要慎重！！！

递归函数

递归函数指的是：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。递归类

似于大家中学数学学习过的“数学归纳法”。每个递归函数必须包含两个部分：

1. 终止条件

表示递归什么时候结束。一般用于返回值，不再调用自己。

2. 递归步骤

把第 n 步的值和第 n-1 步相关联。

嵌套函数(内部函数)

嵌套函数：

在函数内部定义的函数！

一般在什么情况下使用嵌套函数？

1. 封装 - 数据隐藏

外部无法访问“嵌套函数”。

2. 贯彻 DRY(Don’t Repeat Yourself) 原则

嵌套函数，可以让我们在函数内部避免重复代码。

3. 闭包

后面会详细讲解。

nonlocal 关键字

nonlocal

用来声明外层的局部变量。

global

用来声明全局变量。

LEGB 规则

Python 在查找“名称”时，是按照 LEGB 规则查找的：

Local-->Enclosed-->Global-->Built in

Local 指的就是函数或者类的方法内部

Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）

Global 指的是模块中的全局变量

Built in 指的是 Python 为自己保留的特殊名称。

如果某个 name 映射在局部(local)命名空间中没有找到，接下来就会在闭包作用域

(enclosed)进行搜索，如果闭包作用域也没有找到，Python 就会到全局(global)命名空

间中进行查找，最后会在内建(built-in)命名空间搜索（如果一个名称在所有命名空间

中都没有找到，就会产生一个 NameError）

实操作业

九、面向对象初步

面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型软件设计而来的。面向对象编程使程序的扩展性更强、可读性更好，使的编程可以像搭积木一样简单。

面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。 Python 完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。

Python 中，一切皆对象。我们在前面学习的数据类型、函数等，都是对象。

注：Python 支持面向过程、面向对象、函数式编程等多种编程范式。

Python 中，“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。

定义类的语法格式如下：

class 类名：

类体

要点如下：

1. 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。

2. 类体中我们可以定义属性和方法。

3. 属性用来描述数据，方法(即函数)用来描述这些数据相关的操作

【操作】一个典型的类的定义

class Student:

        def __init__(self,name,score): #构造方法第一个参数必须为 self

                self.name = name #实例属性

                self.score = score

        def say_score(self): #实例方法

               print(self.name,'的分数是：',self.score)

s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法

s1.say_score()

__init__构造方法和__new__方法

我们可以更进一步的说，一个 Python 对象包含如下部分：

1. id（identity 识别码）

2. type（对象类型）

3. value（对象的值）

(1) 属性（attribute）

(2) 方法（method）

创建对象，我们需要定义构造函数__init__()方法。构造方法用于执行“实例对象的初始化工

作”，即对象创建后，初始化当前对象的相关属性，无返回值。

__init__()的要点如下：

1. 名称固定，必须为：__init__()

2. 第一个参数固定，必须为：self。 self 指的就是刚刚创建好的实例对象。

3. 构造函数通常用来初始化实例对象的实例属性

4. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。比如：s1 = Student('张三', 80)

5. __init__()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”

6. __new__()方法: 用于创建对象，但我们一般无需重定义该方法。

7. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参

的__init__方法，系统不创建默认的__init__方法。

注：

1. Python 中的 self 相当于 C++中的 self 指针，JAVA 和 C#中的 this 关键字。Python 中，

self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做 self。

实例属性和实例方法

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

1. 实例属性一般在__init__()方法中通过如下代码定义：

self.实例属性名 = 初始值

2. 在本类的其他实例方法中，也是通过 self 进行访问：

self.实例属性名

3. 创建实例对象后，通过实例对象访问：

obj01 = 类名() #创建对象，调用__init__()初始化属性

obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

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

函数体

方法的调用格式如下：

对象.方法名([实参列表])

要点：

1. 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。

2. 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。

· 函数和方法的区别

1. 都是用来完成一个功能的语句块，本质一样。

2. 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。

3. 直观上看，方法定义时需要传递 self，函数不需要。

__del__方法(析构函数)和垃圾回收机制

__call__方法和可调用对象

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。

艾卡西亚暴雨o

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记（自用）

一、整数divmod()函数可以同时得到商和余数，返回的是一个元组。round（value）：可以返回四舍五入的值返回当前时间： import time time.time(),但是计算机的时间是从1970年1月1日0：00：00开始返回值是秒的浮点数。二、字符串： 8位的ASCLL码是16位的Unicode子集转义字符： \续行符 ...
复制链接

扫一扫