这篇文章主要介绍了学完python的感想，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下。
Source code download: 本文相关源码
还没有接触Python时，我以为这门语言会和C++有着天壤之别，但当我真正开始接触它时，才发现，Python与C++非常相似却又非常不同，刚上手时，Python给我的第一感受就是舒服，自我感觉它比C++更容易上手，虽然之前一直在学习C++，但却没有一点不适应，Python给我的感觉就是非常的简洁，且跑出来的程序还非常高效与完整，正对应了“Python之禅”里的
"Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense."
Python的方方面面提起了我的学习兴趣，是我不停地向往深处学习，去感受Python更多的魅力，同时提升自己的能力，让自己变强。
学习Python第一周：
凭借着C++的基础，第一周的学习非常顺利，面对去年打了一学期的分支与循环，码起代码来得心应手，练习题也是毫无压力，但到后面我逐渐想到了一个问题，Python和C++终究是两种语言，我不能单凭靠着C++的编程逻辑来做Python，于是到后面开始逐渐向Python的编程逻辑靠拢，使用Python特有的知识来完成作业与练习练手的70个超火python小项目。
第一天学习时，变量的类型令我眼前一亮：
还有变量类型的转换：（红色表示的是最基础要用到的）
int(x [,base ]) 将x转换为⼀个整数
float(x ) 将x转换为⼀个浮点数
complex(real [,imag ]) 创建⼀个复数，real
为实部，
imag
为虚部
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x
转换为表达式字符串
eval(str ) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象
tuple(s ) 将序列 s 转换为⼀个元组
list(s ) 将序列 s 转换为⼀个列表
chr(x ) 将⼀个整数转换为⼀个Unicode
字符
ord(x ) 将⼀个字符转换为它的ASCII
整数值
hex(x ) 将⼀个整数转换为⼀个⼗六进制字符串
oct(x ) 将⼀个整数转换为⼀个⼋进制字符串
bin(x ) 将⼀个整数转换为⼀个⼆进制字符串
例如 eval() f=eval(input()) 当你不确定你输入的是什么类型时，就可以使用此类型转换。
再往后的几天，分别学习了
条件语句、循环语句以及关于
字符串的一些知识。
对于条件语句与循环语句，因为有着c++的基础，比较容易上手，而且在接触的时候发现了许多微妙之处，就比如在Python中，不管是if，while，for，还是之后学习的函数与类，它都没有用到大括号{}，所以在编写程序的时候，一定要注意每一行所在的位置，否则不是报错，就是程序的运行结果事与愿违。
之后，再次令我大开眼界的是
字符串的使用---
除了灵活的下标以外，它还有着许多便捷的操作方法，如果好好利用，就会让程序更加简洁与高效，下面就是几个常用的操作方法---
1.查找：
find()：字符串序列
.
find
(
⼦串
,
开始位置下标
,
结束位置下标
)
如果找到就返回该字串的下标，不存在就返回-1；
index():与find()基本一样，不同之处在于，如果没找到，就会直接报错；如果在index和find前面加 个’r‘，rfind，rindex，就会变成从右边开始寻找。
count():
字符串序列
.
count
(
⼦串
,
开始位置下标
,
结束位置下标
)
返回某个⼦串在字符串中出现的次数
2.修改：
replace()：替换
字符串序列
.
replace
(
旧⼦串
,
新⼦串
,
替换次数
)
split()：按照指定字符分割字符串
字符串序列
.
split
(
分割字符
,
num
)
join()
：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串
例如：
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))
capitalize()
：将字符串第⼀个字符转换成⼤写。
title()
：将字符串每个单词⾸字⺟转换成⼤写。
lower()
：将字符串中⼤写转⼩写。
upper()
：将字符串中⼩写转⼤写。
lstrip()
：删除字符串左侧空⽩字符。
rstrip()
：删除字符串右侧空⽩字符。
strip()
：删除字符串两侧空⽩字符。
ljust()
：返回⼀个原字符串左对⻬
,
并使⽤指定字符
(
默认空格
)
填充⾄对应⻓度 的新字符串。
字符串序列
.
ljust
(
⻓度
,
填充字符
)
rjust()
：返回⼀个原字符串右对⻬
语法和 ljust()相同。
center()
：返回⼀个原字符串居中对⻬
,
语 法和ljust()
相同。
在这举个简单的例子，想我们熟悉的输出金字塔，就可以运用center()
j=1
i=1
while j<=5:
while i:
a=(2*i-1)*'*'
print(a.center(9,' '))
break
i+=1
j+=1
3.判断：
startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设 置开始和结束位置下标（可省略），则在指定范围内检查。 字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
endswith()：：检查字符串是否是以指定⼦串结尾，
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回 False。
isspace()
：如果字符串中只包含空⽩，则返回
True
，否则返回
False
。
--------------------------------------------------------------------------------------------
之后，又开始了对数据类型的进一步学习：
列表、元组、集合、字典。
1.对于
列表的话，最重要的就是玩懂它的下标，以及熟练掌握各种函数。
例如：
index()
：返回指定数据所在位置的下标 。
（not） in
：判断指定数据（不）在某个列表序列，如果在返回
True
，否则返回
False
extend()
：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。它与append()不同的是，如果是单个数据，他将逐一字符加到列表中。
insert()：指定位置新增数据。
列表序列
.
insert
(
位置下标
,
数据
)
删除：
del
⽬标
pop()
：删除指定下标的数据
(
默认为最后⼀个
)
，并返回该数据。
remove()
：移除列表中某个数据的第⼀个匹配项。
clear()
：清空列表
修改：
逆置：reverse()
排序：sort()
reverse
表示排序规则，
reverse = True
降序，
reverse = False
升序（默认）
复制：copy()
除此之外，也可以
列表嵌套
:
name_list
= [[
'
⼩明
'
,
'
⼩红
'
,
'
⼩绿
'
], [
'Tom'
,
'Lily'
,
'Rose'
], [
'
张三
'
,
'
李四
'
,
'
王五
'
]]
print
(
name_list
[
2
][
1
])#输出李四。
2.
元组
：
与列表类似，不同的是元组内数据不可修改，而且数据之间要用逗号隔开，数据可以是不同类型。
3.
集合：
创建集合使⽤
{}
或
set()
， 但是如果要创建空集合只能使⽤
set()
，因为
{}
⽤来创建空字典。
1. 集合可以去掉重复数据；
2. 集合数据是⽆序的，故
不⽀持下标
增添：
add()
update(),
追加的数据是序列
删除数据与列表类似，不同的是，
remove()
，删除集合中的指定数据，如果数据不存在则报错。
discard()
，删除集合中的指定数据，如果数据不存在也不会报错。
4.
字典：
最根本的就是键值对。
增加：
字典序列[key] = 值
删：
del() / del
：删除字典或删除字典中指定键值对。
clear()
：清空字典
查
：
字典序列.get(key, 默认值
) ：
如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。
keys()、values()、items()，可以用于字典循环遍历。
--------------------------------------到这第一周就完事儿了---以下是
第二周的总结-------------------------------
公共操作：
运算符：
+ 合并
* 复制
in / not in
公共⽅法：
len()
del()
range()
enumerate()
数据类型转换：
tuple()
list()
set()
推导式：
创建⼀个
0-10
的列表。
利用推导式，则
list1 = [i for i in range(10)]
print(list1)
也可在后面加if，构成条件推导式。
以及多个
for
循环实现列表推导式
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
#[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
以及
字典推导式
和
集合推导式
。
=========
函数：
在这里放上一段练习的
通讯录代码，其中的基础知识点也能体现个差不多。
def cai():
print('--------------------')
print('1.添加联系人')
print('2.删除联系人')
print('3.查找联系人')
print('4.修改联系人信息')
print('5.显示全部联系人')
print('6.退出系统')
print(20*'-')
info=[]
def add():
name=input('请输入姓名：')
id=input('请输入id：')
tel=input('请输入电话：')
global info
for i in info:
if name==i['name']:
print('已有该联系人。')
return
info_zi={}
info_zi['name']=name
info_zi['id']=id
info_zi['tel']=tel
info.append(info_zi)
print(info)
def del_info():
name=input('请输入姓名：')
global info
for i in info :
if name == i['name']:
info.remove(i)
else: print('查无此人。')
print(info)
def finding():
name=input('请输入你要查找人的姓名：')
global info
for i in info :
if name==i['name']:
print(f"这个人的姓名是{i['name']},id是{i['id']}，电话是{i['tel']}")
break
else:
print('查无此人。')
def change():
name=input('请输入你要修改的联系人姓名：')
global info
for i in info:
if name==i['name']:
i['tel']=input('请输入新的手机号：')
break
else:
print('查无此人。')
print(info)
def all():
global info
print('姓名\t学号\t电话')
for i in info:
print(f"{i['name']}\t{i['id']}\t{i['tel']}")
while 1:
cai()
a=int(input('请选择功能:'))
if a == 1:
add()
elif a==2:
del_info()
elif a==3:
finding()
elif a==4:
change()
elif a==5:
all()
elif a==6:
y=input('您确定要退出吗？yes or no:')
if y=='yes':
break
else:
print('格式错误，请重新输入。')
以及还有个小知识点，就是help(函数名)，它用于查看函数的说明文档，写多行代码时能起很大方便。除此之外，也可以嵌套使用。
再进一步研究函数，会有位置参数、关键字参数、缺省参数、不定长参数（*args、**kwargs）、拆包和交换变量值，除此之外，还有函数的引用，由此可知：
可变类型：
列表
字典
集合
不可变类型：
整型
浮点型
字符串
元组
当然，还学了那个早就听说过的
递归（重要）
。
特点：
函数内部⾃⼰调⽤⾃⼰
必须有出⼝
例如：
# 3 + 2 + 1
def
sum_numbers
(
num
):
# 1.
如果是
1
，直接返回
1 --
出⼝
if
num
==
1
:
return
1
# 2.
如果不是
1
，重复执⾏累加
:
result
=
num
+
sum_numbers
(
num
-
1
)
# 3.
返回累加结果
return
result
sum_result
=
sum_numbers
(
3
)
#
输出结果为
6
print
(
sum_result
)
---------------------------
lambda
语法
lambda
表达式的参数可有可⽆，函数的参数在
lambda
表达式中完全适⽤。
lambda
函数能接收任何数量的参数但只能返回⼀个表达式的值
实现a+b ：
print
((
lambda
a
,
b
:
a
+
b
)(
1
,
2
))
以及前面学到的args、kwargs；
print
((
lambda
*
args
:
args
)(
10
,
20
,
30
))
print
((
lambda
**
kwargs
:
kwargs
)(
name
=
'python'
,
age
=
20
))
也可以：
print
((
lambda
a
,
b
:
a
if
a
>
b
else
b
)(
1000
,
500
))
列表数据按字典
key
的值排序
--------------
⾼阶函数
abs() #绝对值
1.
def
add_num
(
a
,
b
):
return
abs
(
a
)
+
abs
(
b
)
result
=
add_num
(
-
1
,
2
)
print
(
result
)
# 3
2.
def
sum_num
(
a
,
b
,
f
):
return
f
(
a
)
+
f
(
b
)
result
=
sum_num
(
-
1
,
2
,
abs
)
print
(
result
)
# 3
（我觉得第二种比较。。强）
map(func, lst) #
将传⼊的函数变量
func
作⽤到
lst
变量的每个元素中，并将结果组成新的列表
(Python2)/ 迭代器(Python3)
返回。
reduce(func(x,y)，lst)
，其中
func
必须有两个参数。每次
func
计算的结果继续和序列的下⼀个元素做累
积计算。
fifilter(func, lst)
函数⽤于过滤序列
,
过滤掉不符合条件的元素
,
返回⼀个
fifilter
对象
,
。如果要转换为列表
, 可以使⽤ list()
来转换。
---------------------函数先到这，接下来就是
文件操作
与
面向对象
le-----------------------------------
这两部分内容是难点，学起来可能有点抽象，但是如果多加练习与揣摩，总会弄熟练的。
先放张图--
打开用open(name，mode)，其中mode就是上面表格中各种，，mode
写用write() #对象对象.write('内容')
读 用read()、readlines()、readline()
以及seek()：⽂件对象.seek(偏移量, 起始位置）
起始位置：
0：⽂件开头
1：当前位置
2：⽂件结尾
关闭就用close()
接下来，就是比较头疼的文件备份：
# 1. 用户输入目标文件 sound.txt.mp3
old_name = input('请输入您要备份的文件名：')
# print(old_name)
# print(type(old_name))
# 2. 规划备份文件的名字
# 2.1 提取后缀 -- 找到名字中的点 -- 名字和后缀分离--最右侧的点才是后缀的点 -- 字符串查找某个子串rfind
index = old_name.rfind('.')
# print(index)
# 4. 思考：有效文件才备份 .txt
if index > 0:
# 提取后缀
postfix = old_name[index:]
# 2.2 组织新名字 = 原名字 + [备份] + 后缀
# 原名字就是字符串中的一部分子串 -- 切片[开始:结束:步长]
# print(old_name[:index])
# print(old_name[index:])
# new_name = old_name[:index] + '[备份]' + old_name[index:]
new_name = old_name[:index] + '[备份]' + postfix
print(new_name)
# 3. 备份文件写入数据(数据和原文件一样)
# 3.1 打开 原文件 和 备份文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')
# 3.2 原文件读取，备份文件写入
# 如果不确定目标文件大小，循环读取写入，当读取出来的数据没有了终止循环
while True:
con = old_f.read(1024)
if len(con) == 0:
# 表示读取完成了
break
new_f.write(con)
# 3.3 关闭文件
old_f.close()
new_f.close()当中，还有个重要的os模板
⽂件重命名：os.rename(⽬标⽂件名, 新⽂件名)
删除文件：os.remove(⽬标⽂件名)
创建文件夹：os.mkdir(⽂件夹名字)
删除文件夹：os.rmdir(⽂件夹名字)
获取当前目录：os.getcwd()
改变默认目录：os.chdir(⽬录)
获取目录列表：os.listdir(⽬录)
-----------------------------
面向对象：（与C++的类类似，但有着细微且巧妙的区别）
class
类名
():
代码
对象名
=
类名
()
可在类外：
对象名
.
属性名
可在类外：
self
.
属性名
以及很好用的魔法方法：
__init__()
:
初始化
__str__()
:
输出对象信息
__del__()
:
删除对象时调⽤
在这放上一段来源于网络的代码（
侵删
），可以更好地用于快速复习：
# 1. 定义类：初始化属性、被烤和添加调料的方法、显示对象信息的str
class SweetPotato():
def __init__(self):
# 被烤的时间
self.cook_time = 0
# 烤的状态
self.cook_state = '生的'
# 调料列表
self.condiments = []
def cook(self, time):
"""烤地瓜方法"""
# 1. 先计算地瓜整体烤过的时间
self.cook_time += time
# 2. 用整体烤过的时间再判断地瓜的状态
if 0 <= self.cook_time < 3:
# 生的
self.cook_state = '生的'
elif 3 <= self.cook_time < 5:
# 半生不熟
self.cook_state = '半生不熟'
elif 5 <= self.cook_time < 8:
# 熟了
self.cook_state = '熟了'
elif self.cook_time >= 8:
# 烤糊了
self.cook_state = '烤糊了'
def add_condiments(self, condiment):
# 用户意愿的调料追加到调料列表
self.condiments.append(condiment)
def __str__(self):
return f'这个地瓜的被烤过的时间是{self.cook_time}, 状态是{self.cook_state}, 调料有{self.condiments}'
# 2. 创建对象并调用对应的实例方法
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒面儿')
print(digua1)
digua1.cook(2)
digua1.add_condiments('酱油')
print(digua1)
结果：
这个地瓜的被烤过的时间是0, 状态是生的, 调料有[]
这个地瓜的被烤过的时间是2, 状态是生的, 调料有['辣椒面儿']
这个地瓜的被烤过的时间是4, 状态是半生不熟, 调料有['辣椒面儿', '酱油']-----------------------------------------------那么，第二周的学习就到这了-------------------------------------------
-----------------------------------------------------------第三周-------------------------------------------------------------
相对于第二周，第三周是对第二周更深的研究与学习，更加丰富了，例如继承、类方法、异常、模块与包。
继承：有单继承和多继承；
⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法。
继承的特点：
1.⼦类默认拥有⽗类的所有属性和⽅法
2.⼦类重写⽗类同名⽅法和属性
3.⼦类调⽤⽗类同名⽅法和属性
除此之外，super()
⽅法快速调⽤⽗类⽅法
私有权限
1.不能继承给⼦类的属性和⽅法需要添加私有权限
2.语法：
class
类名
():
#
私有属性
__
属性名
=
值
#
私有⽅法
def
__
函数名
(
self
):
代码
当然，可以用get_xx来获取私有值，用set_xx来修改私有值。
类属性与类方法：
首先先了解一下多态，多态指的是⼀类事物有多种形态，（⼀个抽象类有多个⼦类，因⽽多态的概念依赖于继承）。
步骤：
定义⽗类，并提供公共⽅法
定义⼦类，并重写⽗类⽅法
传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同
类属性就是
类对象
所拥有的属性，它被
该类的所有实例对象 所共有
。
类属性可以使⽤
类对象
或
实例对象
访问。
类属性的优点：
类的实例 记录的某项数据 始终保持⼀致时，则定义类属性。
实例属性 要求 每个对象 为其 单独开辟⼀份内存空间 来记录数据，⽽ 类属性 为全类所共有 ，仅占⽤⼀份内存，更加节省内存空间。（
实例属性不能通过类访问
）
类⽅法特点
第⼀个形参是类对象的⽅法
需要⽤装饰器
@classmethod
来标识其为类⽅法，对于类⽅法，
第⼀个参数必须是类对象
，⼀般以 cls 作为第⼀个参数。
使用场景：
当⽅法中
需要使⽤类对象
(
如访问私有类属性等
)
时，定义类⽅法
类⽅法⼀般和类属性配合使⽤
@classmethod
def
xx
():
代码
静态⽅法特点
需要通过装饰器
@staticmethod
来进⾏修饰，
静态⽅法既不需要传递类对象也不需要传递实例对象
（形参没有
self/cls
）
。
静态⽅法 也能够通过
实例对象
和
类对象
去访问。
@staticmethod
def
xx
():
代码
异常：
try
:
可能发⽣错误的代码
except
异常类型
:
如果捕获到该异常类型执⾏的代码
异常类型：有NameError、ZeroDivisionError等；其中
Exception
是所有程序异常类的⽗类。
else
表示的是如果没有异常要执⾏的代码。
fifinally
表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件
捕获异常：
except
异常类型
:
代码
except
异常类型
as
xx
:
代码
⾃定义异常
class
异常类类名
(
Exception
):
代码
#
设置抛出异常的描述信息
def
__str__
(
self
):
return
...
# 2.
抛出异常
raise
异常类名
()
#
捕获异常
except
Exception
...
模块和包：
Python
模块
(Module)
，是⼀个
Python
⽂件，以
.py
结尾，包含了
Python
对象定义和
Python
语句。
模块能定义函数，类和变量，模块⾥也能包含可执⾏的代码。
举个简单的例子，就像之前我们学习的 import random random.randint()或者import time
import 模块名
from 模块名 import 功能名
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
另外：
测试模块
#
只在当前⽂件中调⽤该函数，其他导⼊的⽂件内不符合该条件，则不执⾏
testA
函数调⽤
if
__name__
==
'__main__'
:
模块定位顺序
当导⼊⼀个模块，
Python
解析器对模块位置的搜索顺序是：