欢迎访问我的GitHub这里分类和汇总了欣宸的全部原创(含配套源码)：本篇概览欣宸是个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、clearpop()会弹出最后一个元素：也可以将索引作为入参传入，这样就能删除指定元素：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相似，由多个键值对构成，键和值之间用冒号分隔，多个键值之间用逗号分隔，外面用大括号包裹：字典看起来很像jsonitems方法返回所有元素，keys返回所有键，values返回所有值：可以用键查找值，和Java的map一样，不过语法是中括号：也可以用get方法返回键对应的值，还能指定键不存在时的默认值：直接用方括号，可以修改，如果键不存在就是添加：update方法的入参是另一个字典，该方法可以将入参字典的内容合并进自身：pop方法删除指定元素，popitem方法删除最后一个元素：集合(Set)提到Set，Java程序员应该不陌生，就是咱们经常用来排重的那个Set，是个无序元素集集合用逗号分隔，大括号包裹：小结三种包裹方式：列表方括号，元组圆括号，字典和集合大括号（字典的元素是键值对，集合是单个元素），另外元组可以不包裹，有逗号就行set方法可以将列表转为集合：集合的元素都是不可变类型的，如数值、字符串、元组可变类型不能作为集合的元素，如列表、字典、集合，至于其中原因，看看下图红框的错误信息，如果您是个Java程序员，应该get到了：可以用减号或者difference方法求两个集合的差集：程序逻辑控制if判断，是用if、elif、else的组合，注意if、elif、else的行末尾都有冒号：python不支持switchif判断的三元操作符，赋值的时候可用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 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.pyhello 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 test1import test.test2 as test2test1.doTest1()test2.doTest2()

运行hello.py试试：

will$ python hello.pyhello test1!hello test2!

内建模块：collectionsJava程序员对collections包不会陌生，这里面都是一些和容器相关的类，为咱们的开发提供了极大便利，接下来看看该模块常用的几个类namedtuple：可以用名字访问内容的元组子类，从下面的代码可见，namedtuple可以方便的定义一个对象，很像java中的bean：

from collections import namedtuple# 自定义元组对象Student = namedtuple('Student', ['name', 'age'])# 实例化Studentstudent = 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'>Tom11

内建模块：dequedeque是双向队列，在增加和删除数据的时候比列表的性能更好（列表的读性能更好），基本操作如下所示：

from collections import deque# 实例化dequedq = 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.py1. 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])

内建模块：OrderedDictOrderedDict是有顺序的字典，如果您了解LFU（Least frequently used）算法，那么就很容易理解有序的字典了，OrderedDict中的顺序是元素被添加的先后顺序，普通用法如下：

from collections import OrderedDict# 实例化od = OrderedDict()# 添加od['a'] = 1od['c'] = 2od['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.py1. 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)])

内建模块：defaultdictdefaultdict容易理解：带有默认值的字典，用法如下所示，要注意的是defaultdict实例化的入参是lambda表达式，至于这个lambda，相信java程序员并不陌生：

from collections import defaultdictdd = defaultdict(lambda: 'ABC')dd['a'] = 1# 打印一个存在的键值print(dd['a'])# 打印一个不存在的键值print(dd['b'])

输出如下：

will$ python defaultdict.py 1ABC

内建模块：CounterCounter提供了计数器功能，下面的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过程中的简化版笔记，希望能帮助您在初期抓住重点，快速入门；欢迎关注头条号：程序员欣宸学习路上，你不孤单，欣宸原创一路相伴...