来自Java程序员的Python新手入门小结 python

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

本篇概览

欣宸是个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 对象名

【来自Java程序员的Python新手入门小结】例如：

文章图片

上述极简的方式是不推荐使用的，因为缺少了namespace隔离，在API的正确性上就缺少了保障

关于自己的模块

假设有一个python文件hello.py，内容如下，定义了名为doHello的方法，再执行一下试试：

def doHello(): print("hello world!")doHello()

现在另一个文件test.py，里面会调用hello.py中的doHello的方法：

import hellohello()

执行命令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 test2test1.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 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 defaultdictdd = 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 Counter({ 'aa': 2, 'bb': 1, 'cc': 1}) { 'aa': 2, 'bb': 1, 'cc': 1} most_common's type 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 = addrdef 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))