本篇概览
- 欣宸是个Java程序员，最近正在学习Python，本文记录了学习过程，以及一点自己的思考，主要用途是作为笔记来总结和温习，另外如果您也是一位初学Python的Java程序员，希望本文能给您一些参考；
版本
操作系统：macOS Big Sur (11.6) Anaconda3：2021.05 python：3.7.3 Jupyter Notebook：5.7.8
工具
- 编辑器用的是Jupyter Notebook，以下三个快捷键最常用到，尤其是第三个，执行当前行，并新增一行：
- 废话不多说了，直接开始动手操作；
除法
- 一个斜杠的除法，结果是浮点型，两个斜杠的触发，结果是整形：
字符串
- 格式化的时候，可以不指定参数索引，此时按照出现顺序处理：
- 也可以在花括号中添加数字：
- 还可以在花括号中添加冒号，在冒号之后添加特定的输出格式
- 保留小数点后三位，f表示浮点数：
- 带符号保留小数点后三位，f表示浮点数：
- 不显示小数：
列表
- 逗号分隔，方括号包裹：
- 列表各个元素的类型无需相同（这一点和Java数组是不同的）
- 访问列表中的元素，使用方括号 索引(从0开始)：
- 索引数值可以为负，负一表示倒数第一：
- 与字符串的字符不同之处在于，列表的元素可以修改：
- 分片，下面代码表示从0开始，一直取到2-1位置（左闭右开）：
- 分片的时候，冒号左边不填就表示从0开始，右边不填表示直到最后一个元素：
- 分片可以接受第三个参数：步长，下面的表示每遍历两个元素才取一个
- 当步长等于负一的时候，相当于反转了：
- 用加号实现两个列表相连：
- 列表乘以数字N，表示生成一个新的列表，内容是原列表的N份复制：
- append：尾部追加元素
- insert：将元素插入在指定位置
- extend：将一个列表追加到另一个列表尾部
- 方法id可以查看对象的内存地址，如下图，可见经历了append、insert、extend等操作后，内存地址不变，也就是说这些都是原地操作(in place)：
列表的删除操作
- 删除列表元素有三种方式：pop、remove、clear
- pop()会弹出最后一个元素：
- 也可以将索引作为入参传入，这样就能删除指定元素：
- remove方法的入参是列表中的值，也就是找到列表中与入参相同的元素，将其删掉，下图可见，myList中有两个’abc’，用remove会删除第一个：
- clear方法会清空列表：
列表的记数和索引
- count方法统计指定元素在列表中的数量，从下图可见1在列表中出现了两次：
- index查找指定元素出现的位置：
列表排序
- sort方法用来排序，默认是比较元素大小：
- 默认是升序，添加reverse=True表示降序：
- sort操作的是列表对象本身，还可以用全局函数sorted来排序，该函数会生成一个新的副本，如下图，newList是排序后的列表，而原有的myList保持不变：
与列表相关的常用全局函数
- 除了sorted，还有一些常用的全局函数和列表有关：
- operator(取代原有的cmp)，用于比较大小以及是否相等：
- len：计算个数
- max：返回最大值
- min：返回最小值
- list：元组转为列表
- zip：两个列表中，同位置元素结合成一个元组，最终得到一个元组列表：
- enumerate：将指定列表的每个元素与其位置下表组成一个元组，最终得到一个元组列表（和上面的zip用法相似，不过简单多了，range操作已经在enumerate内部实现）,如下图：
元组
- 元组与列表相似，但是一旦创建就不能修改，创建使用的是圆括号（列表是方括号）
- 要注意的是，只有一个元素的元组也要带逗号，例如(1,)，这很好理解，毕竟(1)就是个整数而已
- 没有括号，只有逗号，也是元组：
- 下标操作和列表相同：
- 列表转元组用tuple函数：
- tuple函数还能将字符串直接转为元组：
- 修改元组会失败：
- 修改元组的思路是创建新的元组，如下图，用三个元组拼接的方式生成了一个新的元组，相比旧的，新元组的第三个元素已经从2变为’a’，给人以修改过的感觉:
字典
- 字典和Java的map相似，由多个键值对构成，键和值之间用冒号分隔，多个键值之间用逗号分隔，外面用大括号包裹：
- 字典看起来很像json
- items方法返回所有元素，keys返回所有键，values返回所有值：
- 可以用键查找值，和Java的map一样，不过语法是中括号：
- 也可以用get方法返回键对应的值，还能指定键不存在时的默认值：
- 直接用方括号，可以修改，如果键不存在就是添加：
- update方法的入参是另一个字典，该方法可以将入参字典的内容合并进自身：
- pop方法删除指定元素，popitem方法删除最后一个元素：
集合(Set)
- 提到Set，Java程序员应该不陌生，就是咱们经常用来排重的那个Set，是个无序元素集
- 集合用逗号分隔，大括号包裹：
- 小结三种包裹方式：列表方括号，元组圆括号，字典和集合大括号（字典的元素是键值对，集合是单个元素），另外元组可以不包裹，有逗号就行
- set方法可以将列表转为集合：
- 集合的元素都是不可变类型的，如数值、字符串、元组
- 可变类型不能作为集合的元素，如列表、字典、集合，至于其中原因，看看下图红框的错误信息，如果您是个Java程序员，应该get到了：
- 可以用减号或者difference方法求两个集合的差集：
程序逻辑控制
- if判断，是用if、elif、else的组合，注意if、elif、else的行末尾都有冒号：
- python不支持switch
- if判断的三元操作符，赋值的时候可用if else组合：
- 普通的for循环：
- 内置函数range可以创建整数列表，也能在for循环中遍历：
- while循环的语法和java相似：
- 循环中的break和continue与Java类似，就不赘述了
推导式：列表
- 格式如下：
[生成表达式 for 变量 in 序列或迭代对象]- 测试如下，a就是列表推导式生成的列表：
- 还可以通过if增加筛选条件，例如下面是只保留偶数：
- 如果列表的元素也是列表，我们可以用列表推导将其解开，平铺为一层，下图的例子中，a_element是a的元素，a_element自身也是列表，还可以用推导将其展开：
推导式：字典
- 对字典用推导式，可以取得键和值的处理，下面是用推导式生成一个新的字典，剔除了键为age的键值对：
推导式：集合
- 下面使用推导式，利用列表生成一个新集合，里面的值是原列表每个元素的平方，而且由于集合的不重复性，原列表中重复的元素已经被过滤为只剩一个：
导入库
- 语法：
import 模块名 [as 别名]- 例如导入math模块来计算正弦值：
- 如果觉得每次在代码中写math太麻烦，还可以在导入时设置别名：
- 如果觉得别名也麻烦，能不能把m.也去掉，可以用以下语法：
from 模块名 import 对象名例如：
- 上述极简的方式是不推荐使用的，因为缺少了namespace隔离，在API的正确性上就缺少了保障
关于自己的模块
- 假设有一个python文件hello.py，内容如下，定义了名为doHello的方法，再执行一下试试：
def doHello():
print("hello world!")
doHello()- 现在另一个文件test.py，里面会调用hello.py中的doHello的方法：
import hello
hello()- 执行命令python test.py，结果如下，可见hello world!输出了两次：
will$ python test.py
hello world!
hello world!- 上述结果显然不是我们想要的，test.py只是想使用doHello方法，结果将hello.py中的doHello()也执行了，需要一种方式来避免test.py中的doHello()被执行
- 这时候内置变量name就派上用场了（注意前后都是两个下划线），将hello.py改成如下内容，如果执行python hello.py，内置变量name的值就是main，其他时候，例如hello.py被其他文件import的时候，它的值就是模块名(这里就是hello)：
def doHello():
print("hello world!")
if __name__=='__main__':
doHello()- 再试试python test.py，这次只有一次输出了：
will$ python test.py
hello world!- 我们再试试python hello.py，也能按照预期输出：
will$ python hello.py
hello world!包
- 对于Java程序员来说，包很好理解，在python中也很相似，接下来咱们尝试一下，创建名为test的包，里面有两个模块：test1和test2
- 加入包名为test，咱们创建名为test的文件夹
- test文件夹下，新增文件init.py，这是个空文件
- 创建文件test1.py：
def doTest1():
print("hello test1!")- 再创建文件tes2.py:
def doTest2():
print("hello test2!")- 现在回到test2.py文件的上一层目录，创建文件hello.py，用来验证如何使用包，可见访问方式是包名.模块名.方法名：
import test.test1 as test1
import test.test2 as test2
test1.doTest1()
test2.doTest2()- 运行hello.py试试：
will$ python hello.py
hello test1!
hello test2!内建模块：collections
- Java程序员对collections包不会陌生，这里面都是一些和容器相关的类，为咱们的开发提供了极大便利，接下来看看该模块常用的几个类
- namedtuple：可以用名字访问内容的元组子类，从下面的代码可见，namedtuple可以方便的定义一个对象，很像java中的bean：
from collections import namedtuple
# 自定义元组对象
Student = namedtuple('Student', ['name', 'age'])
# 实例化Student
student = Student('Tom', 11)
# 看一下student的类型
print(type(student))
# 使用name字段
print(student.name)
# 使用age字段
print(student.age)- 执行结果如下，可见student的name和age字段都能方便的访问到，而student实例的类型是class：
will$ python test.py
<class '__main__.Student'>
Tom
11内建模块：deque
- deque是双向队列，在增加和删除数据的时候比列表的性能更好（列表的读性能更好），基本操作如下所示：
from collections import deque
# 实例化deque
dq = deque([1,2,3])
# 队列右侧增加元素
dq.append(4)
print('1. {}'.format(dq))
# 队列左侧增加元素
dq.appendleft(5)
print('2. {}'.format(dq))
# 指定位置增加元素
dq.insert(1, 6)
print('3. {}'.format(dq))
# 最右侧元素弹出（删除）
dq.pop()
print('4. {}'.format(dq))
# 最左侧元素弹出
dq.popleft()
print('5. {}'.format(dq))
# 删除元素，注意2是值，不是位置
dq.remove(2)
print('6. {}'.format(dq))
# 倒排
dq.reverse()
print('7. {}'.format(dq))- 执行结果如下：
will$ python deque.py
1. deque([1, 2, 3, 4])
2. deque([5, 1, 2, 3, 4])
3. deque([5, 6, 1, 2, 3, 4])
4. deque([5, 6, 1, 2, 3])
5. deque([6, 1, 2, 3])
6. deque([6, 1, 3])
7. deque([3, 1, 6])内建模块：OrderedDict
- OrderedDict是有顺序的字典，如果您了解LFU（Least frequently used）算法，那么就很容易理解有序的字典了，OrderedDict中的顺序是元素被添加的先后顺序，普通用法如下：
from collections import OrderedDict
# 实例化
od = OrderedDict()
# 添加
od['a'] = 1
od['c'] = 2
od['b'] = 3
# 顺序是添加的先后顺序
print("1. {}".format(od))
# 打印所有的键
print(od.keys())
# 把一个字典合并进来
od.update({'e':'4'})
# 顺序是添加的先后顺序
print("2. {}".format(od))
# 根据键删除键值对
od.pop('a')
print("3. {}".format(od))
# 把指定键的键值对移到末尾
od.move_to_end('c')
print("4. {}".format(od))- 输出如下：
will$ python ordered.py
1. OrderedDict([('a', 1), ('c', 2), ('b', 3)])
odict_keys(['a', 'c', 'b'])
2. OrderedDict([('a', 1), ('c', 2), ('b', 3), ('e', '4')])
3. OrderedDict([('c', 2), ('b', 3), ('e', '4')])
4. OrderedDict([('b', 3), ('e', '4'), ('c', 2)])内建模块：defaultdict
- defaultdict容易理解：带有默认值的字典，用法如下所示，要注意的是defaultdict实例化的入参是lambda表达式，至于这个lambda，相信java程序员并不陌生：
from collections import defaultdict
dd = defaultdict(lambda: 'ABC')
dd['a'] = 1
# 打印一个存在的键值
print(dd['a'])
# 打印一个不存在的键值
print(dd['b'])- 输出如下：
will$ python defaultdict.py
1
ABC内建模块：Counter
- Counter提供了计数器功能，下面的demo演示了用Counter将列表转为了每个元素的统计结果，要注意的是most_common方法，相当于排序和列表的功能，该方法的返回值是列表，里面的元素是元组：
from collections import Counter
# 一个普通列表
colors = ['aa', 'bb', 'cc', 'aa']
# 将列表传给Counter进行统计
result = Counter(colors)
# 打印result类型
print(type(result))
# 打印result内容
print(result)
# 用内置函数dict将Counter实例转为字典
print(dict(result))
# 取统计值最高的前两个元素
most = result.most_common(2)
# 检查most_common返回值的类型
print("most_common's type {}".format(type(most)))
# 检查most_common返回值的类型
print("most_common's value : {}".format(most))- 输出结果如下：
will$ python Counter.py
<class 'collections.Counter'>
Counter({'aa': 2, 'bb': 1, 'cc': 1})
{'aa': 2, 'bb': 1, 'cc': 1}
most_common's type <class 'list'>
most_common's value : [('aa', 2), ('bb', 1)]内建模块：datetime
- 名为datetime的模块中，有个名为datetime的类
- 还可以实例化datetime对象：
- datetime对象的年月日时分秒等字段：
- 转时间戳：
- 还可以通过strptime方法将指定格式的字符串转为datetime对象：
- datetime对象转字符串也是常见操作，用的是strftime方法：
- 时间的计算，例如一天前，一小时后等操作，可以使用datetime包的timedelta类完成：
- datetime对象可以用减法结算时间差：
- 减法特性在计算日期间隔的时候很有用：
JSON处理
- 利用json进行对象和字符串之间的序列化、反序列化转换：
- 还可以用dump和load方法通过文件进行序列化反序列化操作
内置模块：random
- 生成随机数也是常见操作：
- 还可以产生整形随机数，设置内容范围和递增单位：
- 在一堆内容中做随机选择：
- 用choices方法（注意不是choice），可以随机选择指定数量的结果：
- choices得到的结果可能重复，如果想不重复可以用sample方法：
- 将原有集合数据的顺序打乱，相当于洗牌的效果：
函数
- 基本函数语法：
def 函数名([参数列表]):
函数体- 和Java不同的是，函数的入参类型并不固定：
- 使用关键字pass，可以定义一个空方法：
def test():
pass- 一个函数可以返回多个值（本质上是个元组），调用的时候用多个变量来接收即可：
- 还可以给函数增加说明文档，然后用help命令查看：
- 调用参数的时候可以用参数名=xxx的形式传入参数，此时参数参数的先后顺序可以随意，无所有谁先谁后：
- 可变参数和Java的方法也相似，先看一个星号的可变参数，可以理解为元组：
- 再看两个星号的可变参数，可以理解为字典：
- 对于固定参数的函数，还可以直接将字典作为入参，不过要加两个星号：
- 还可以设置默认参数：
lambda表达式
- java程序员对lambda表达式很熟悉，这里也差不多，来看看如何定义和使用：
- 再来看看几个支持lambda的内置函数，熟悉lambda的使用
- filter：过滤器，下面是个过滤奇偶数的例子，第一个参数是判断是否过滤的逻辑，True保留，第二个参数是列表，最终奇数全部被剔除，只留下偶数：
- map：逐一转换，下面是将奇数转为False，偶数转为True的例子：
- reduce：大名鼎鼎的map reduce，您应该有所耳闻，reduce会将集合中的数据逐个取出来和前面一轮的结果做同样的处理，最典型的当属累加：
- sort：排序，先来看看最简单的：
- sorted可以接受排序处理函数作为参数，例如按照绝对值进行排序，内置函数是abs，被作为参数传给sorted：
- sorted方法会生成一个新的列表，如果想直接改变原列表就不适合用sorted方法了，此时用列表的sort方法即可，如下图，还用了reverse参数试试倒排序的功能：
面向对象
- 身为Java程序员，天天和对象打交道，下面的代码您应该很容易看懂：
- 如果变量名是由两个下划线开始的，就表示改变量是私有成员变量，不能在外部访问：
- 与Java不同的是，创建对象不需要关键字new
- 继承：
class 派生类名 (父类名):
语句...- 下面是个继承的例子，Student是父类，Pupil是子类：
# 父类
class Student:
# 成员变量
name = '未知'
age = 11
__addr= 'ShangHai'
# 构造方法
def __init__(self, name, age, addr):
print('执行构造方法')
self.name = name
self.age = age
self.__addr = addr
def myInfo(self):
print('学生姓名[{}]，年龄[{}，地址[{}]]'.format(self.name, self.age, self.__addr))
class Pupil(Student):
#成员变量
grade = 1
# 构造方法
def __init__(self, name, age, addr, grade):
# 显式调用父类构造方法
Student.__init__(self, name, age, grade)
print('执行构造方法（子类）')
self.grade = grade
# 子类自己的方法
def myGrade(self):
print('学生年级[{}]'.format(self.grade))- 执行效果如下，符合预期：
生成器
- 先回顾一下列表推导，下面的代码会生成一个列表：
a = [x*2 for x in range(10)]- 如果列表很大就会很占用内存空间，此时我们还有另一个选择：生成器，简单的说就是将上述代码的方括号改成圆括号，这样a就不是列表了，而是生成器，这是种特殊的迭代器：
异常处理
- 习惯了java的try-catch-finally，对python的异常处理就容易理解了，捕获和处理如下：
try:
x = 1/0
print('不可能打印这一句')
except ZeroDivisionError as err:
print('发生异常', err)
finally:
print('执行finally')- 输出如下图：
- 关键字raise可以主动抛出异常：
- 以上就是欣宸在自学Python过程中的简化版笔记，希望能帮助您在初期抓住重点，快速入门；
