小甲鱼的Python笔记_小甲鱼python学习笔记

推荐看系列

强烈推荐看：Python 基础（一）：入门必备知识
推荐看：Python基础知识点总结

介绍：Python是一门既简单又功能强大的编程语言，它注重的是如何解决问题而不是编程语言的语法与结构。
详细请看：＜A Byte of Python＞+＜小甲鱼-零基础入门学习Python＞

---

# Python 从0开始计数，而非从1开始（MATLAB）。
# 同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。
# Python的语句末尾不需要分号(;) ———— （1）如果想要多个语句写在同一行，那么你需要使用分号(;)，但强烈不建议。
# 							  ———— （2）如果想要多个语句写在同一行，那么你需要使用逗号(,)，建议（但赋值语句不可用）。
1
2
3
4

1、模块

1.1、基本模块：sys、time、os

import sys

sys.path.append('C:\\Users\\pc\\Desktop')  # 在（搜索路径）列表的末尾新增一个路径。系统默认添加当前文件路径。
# 【sys模块】路径搜索：新增导入模块的路径。
1
2
3
4

import time

start_time = time.time()  # 记录开始时间
end_time = time.time()  # 记录结束时间
duration = end_time - start_time  # 计算时长（单位：秒）
print("PC图像耗时：", duration, "秒")
1
2
3
4
5
6

import os 					# os（operating system, 操作系统）

# os.getcwd()				# 查询当前程序的目录。
# os.listdir(path)			# 列举指定目录下的所有文件名。（1）默认值是'.'代表根目录；（2）'..'代表上一层目录；（3）可自定义路径。
# os.mkdir(path)			# 创建文件夹，如果该文件夹存在，则显示'FileExistsError'。其中：path需包含路径与文件夹名。
# os.remove(path)			# 删除指定的文件
# os.rmdir(path)			# 删除指定的文件夹。该文件夹的目录下必须为空，否则报错。
# os.removedirs(path)		# 删除指定的文件夹及其多层目录。（1）如果目录下有文件，将跳过不删除。（2）最后一层目录下必须为空，否则报错。
# os.rename(old, new)		# 重命名文件或文件夹。例如：os.rename('1', 'test')
# os.system('calc')			# 唤醒windows系统自带的计算器
1
2
3
4
5
6
7
8
9
10

1.2、 dir、doc、help()

# dir						# 如果不提供参数，将返回当前模块中定义的名称列表。
# dir(sys)					# 如果提供一个模块名，将返回模块定义的名称列表。注意：输入的模块同样是列表的一部分。
print('打印print函数', dir(print))			# 打印print函数
print('打印BIF函数', dir(__builtins__))		# 打印Python提供的内置函数（BIF）列表	

# __doc__：获取函数的文档字符串（即获取自定义的函数注释）。		# 例如：(max.__doc__)
print('__doc__', max.__doc__)

# help()：查看函数的说明文档。		# 例如:help(__doc__)
help(max)
1
2
3
4
5
6
7
8
9
10

1.3、if __ name__ == ‘__ main__’

# if __name__ == '__main__'			# 可以等同理解为C++中的int main()

# （1）在作为程序运行的时候，__name__属性的值是'__main__'。		# 即其本身作为主函数
# （2）作为模块导入的时候，__name__属性的值就是该模块的名字。		# 即其作为外部库使用，且只调用函数，忽略其函数调用（若有）。
# 		备注1：该方法让Python知道导入的模块是作为程序运行，还是导入到其他程序中。
# 		备注2：避免导入的模块中本身即有函数定义也有函数调用，进而导致调用时出现BUG（例如：出现双重调用现象）
1
2
3
4
5
6

1.4、读取文件open()

f = open('test.txt', 'w')	# （1）读取文件模式：读模式('r')、写模式('w')或追加模式('a')。
f = open(test.txt)			# （2）直接读取文件：打开一个文件，并返回一个【文件对象】。
f.close()					# 关闭文件
1
2
3

1.5、导入模块的四种方法

##############################################
# 创建自己的模块(my_module.py文件)
# 		def say_hi():        		# 函数定义
# 			print('Hi, world!')		# 函数内语句
# 		__version__ = '0.1'
#####################
# 导入模块
# 		（1）导入整个模块
#				方式一：	import torch			# 导入整个模块，然后从中随时取
#						torch.nn.Conv2d()		
#				
#				方式二：	import torch as t		# 导入整个模块，并自定义新名字
#						t.nn.Conv2d()			
#
# 		（2）从模块中导入指定成员变量
#				方式一：	import torch.nn
#						torch.nn.Conv2d()		# 调用模块中的函数
#
#				方式二：	import torch.nn as nn
#						import torch.nn.functional as f
#						nn.Conv2d()				# 调用模块中的函数
#
#				方式三：	from torch import nn
#						nn.Conv2d()				# 调用模块中的函数
#
#		（3）从模块中导入全部成员变量（不推荐）
#						from torch import *     
##############################################
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2、输入输出

2.1、单行输入

password = input("请输入密码:")  		# 输入数据（备注：只能单行输入）
print('您输入的密码是:', password)  		# 输出数据
1
2

2.2、多行输入

# 导入多行数据
if 1:		# 永远执行
	lines = int(input('请输入变量的个数：'))
else:		# 不执行
	lines = 0
######################################################################
# （1）输入为0，表示跳过函数；
# （2）输入为n，则循环输入n行数据。
######################################################################
text = ''
for ii in range(lines):
	text += input() + '\n'		# 将每一行的字符拼接到字符串中（如：'1\n2\n'）
######################################################################
text_list = []				
for ii in range(lines):
	text_list += input()		# 将每一行的字符保存到列表中（如：['3','4']）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.3、单引号、双引号、三引号

##############################################
# 单引号、双引号、三引号
# 		备注1：在Python中，无论是双引号、单引号或者是三引号，都是字符串；而不带引号，就是数字。
# 		备注2：字符串是不可变的 —— 即字符串一旦创建就不能再改变它。
##############################################
# （1）单引号 + 反斜杠 
print('hi! What\'s up! This is my territory.')

# （2）双引号（双引号可以显示单引号，而无需反斜杠）
print("hi! What's up! This is my territory.")

# （3）在一个字符串中，行末尾的反斜杠表示连接符，即下一行字符串是上一行的延续，属于同一行代码，不增加新的行。
print("hi! What's up! \
		This is my territory.")
		
# （4）三引号。用法同(3)
print('''hi! What's up! \
		This is my territory.''')
		
# （5）通过在字符串前面附加 r 或 R 来指定自然字符串 —— 即指定特殊字符不被处理
print(r'hi! What\'s up! This is my territory.')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3、基本概念

3.1、E计数法、获取数据类型

# E计数法（E或e都可以）：1.5万 = 1.5e4			# 其中，E的意思就是指数10，E后边的数字就是10的多少次幂。

# 获取数据类型：（1）直接获取：type()函数
#			  （2）对比获取：True/False = isinstance（待确定类型数据，指定数据类型）
1
2
3
4

3.2、（算数、逻辑、连接、重复、成员关系）操作符

# 算数操作符：
# （1）整数除法返回float类型			# 例如：(2.0 == 5/2)、(2 == 5//2)、(1.0 == 3.0//2)
# （2）百分号%表示取余数				# 例如：(1 == 5%2)
#
# 逻辑操作符：and、or、not(False == not true)
# 		备注：Python中可以表示：(3 <= 4 <= 5 )等同于(3 <= 4 and 4 <= 5)
#
# 连接操作符：加号(+)		# 字符串相加叫做拼接；数字相加叫做求和。
# 重复操作符：乘号(*)		# 例如：[12,34,12,34,12,34] = [12,34] * 3
#
# 成员关系操作符：in 和 not in				# 例如：(True == 12 in [12, [2, 34]])、(False == 34 in [12, [2, 34]])
# 		备注1：（1）"成员关系操作符"只能判断一个层次的成员关系；
# 		备注2：（2）字符串和列表都可以使用"连接操作符"和"重复操作符"

1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.3、操作符：* 与 **

# Python中的 * 与 ** 操作符的两种用法
# （1）用做运算符，即*表示乘号，**表示次方。效果等同：x**2 == numpy.power(x, 2)
# （2）用于指定函数传入参数的类型的。（详细请看函数）
#			*用于参数前面，表示传入的多个参数将按照元组的形式存储，是一个元组；
#			**用于参数前则表示传入的(多个)参数将按照字典的形式存储，是一个字典。

1
2
3
4
5
6

4、循环语句

4.1、for、while

# 注意：if/for/while/def/class 语句在结尾处包含一个冒号 —— 我们通过它告诉Python下面跟着一个语句块。
##############################################
# for 循环：range(start, stop, step=1)		# 第一个参数(可不输入)默认为0，第三个参数(可不输入)默认为1。
#		（1）range(5)			—— 序列[0,1,2,3,4]			range的步长为1。
# 		（2）range(1, 5)		—— 给出序列[1,2,3,4]		range的步长为1。
# 		（3）range(1, 5, 2)		—— 给出序列[1,3]			range的步长为2。
# 备注：range 仅包含左值(1)，但不包含右值(5)。
for jj in range(1, 16, 5):
	print(jj)
##############################################
# while 循环：	（1）可以有else语句。
# 				（2）如果 while 循环有 else 语句，它将始终被执行。
# 				（3）如果 for 或 while 循环中途终止(break)，对应的 else 将不执行。
number = 23
running = True		# FALSE/True
while running:
	break			# 不执行while循环
	guess = int(input("Enter an integer:"))
	if guess == number:
		print("Congratulation, you guessed it.")
		running = False					# 终止while循环
	elif guess == number:
		print("No, need higher.")
	else:
		print("No, need lower.")
else:
	print("the while loop is over.")	# 跳出循环后执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4.2、continue、break、return、pass、global、None

# continue语句：			跳过当前循环块中的剩余语句，然后继续进行下一轮循环；
# break语句：			停止并跳出当前循环体；
# return语句：			跳出函数并返回一个值；
##############################################
# pass语句				在Python中表示一个"空"的语句块；
# global语句：			全局变量声明。如：global x = 3
# None					表示"空"的特殊类型。如：return None
1
2
3
4
5
6
7

4.3、将if else语句写在一行

# 常用方法
if alpha > 7:
    beta = 999
elif alpha == 7:
    beta = 99
else:
    beta = 0
1
2
3
4
5
6
7

beta = 999 if alpha > 7 else 99 if alpha == 7 else 0
# 断句为：
# beta =
# 		999 if alpha > 7
# 		else 99 if alpha == 7
# 		else 0
1
2
3
4
5
6

# 总结如下
beta1 = (True)打印A if True else (False)打印B
beta2 = (True)打印A if True else ((True)打印B if True else (False)打印C)
1
2
3

5、数据类型 + 数据结构

5.1、数据类型：字符串型str、数值类型（整型int、浮点型float、布尔型bool、复数类型）

# Python的变量在使用时不需要声明或定义数据类型，直接赋值即可。系统会自动依据赋值内容给定数据类型。		
# 区别：（1）Python有字符串类型，但没有char字符类型。（2）没有switch语句。
1
2

5.1.1、数据类型强转：int()、float()、str()

5.1.2、工厂函数：type(int) + type(int())

# 内置函数（Built-in Functions, BIF）转换为工厂函数：
#		type(int)		# class类型
# 		type(int())		# int 类型		# 同理：int()/float()/str()/list()/tuple
1
2
3

5.2、引用 —— 赋值与复制操作的区别

# <引用> ———— 赋值操作+复制操作的区别
# 		备注1：在python中,【赋值变量操作】则其中任意一个有变动，另一个变量自动跟随变动。			例如：my_thing = shop_thing
# 		备注2：在python中,【复制变量操作】可以实现新建一个全新变量，且新变量有任何变动，原变量不改变。		例如：my_thing = shop_thing.copy()
##############################################
shop_list = ['apple', 'mango', 'carrot', 'banana']
my_list = shop_list					# 当前shop_list与my_list的元素相同
del shop_list[0]					# shop_list 与 my_list 将同时删除第一个元素
shop_list[0] = 'ni_hao'				# shop_list 与 my_list 将同时增加元素
print('shop_list', shop_list)
print('my_list', my_list)
del my_list[0]						# my_list 与 shop_list 将同时删除第一个元素
print('shop_list', shop_list)
print('my_list', my_list)
1
2
3
4
5
6
7
8
9
10
11
12
13

5.3、序列（sequence）常用的BIF

# <6 序列 sequence>
# 【列表、元组和字符串】都属于序列；序列是一种统称，而不是具体的数据类型。
# 		备注：索引可以是负数，从序列末尾开始计算。例如：shop_list[-1], 表示序列的倒数第一个元素（即最后一个元素）
#
# 下面介绍【序列的常用BIF】
#		（1）list([iterable])		# 将可迭代对象转换为列表
#		（2）tuple([iterable])		# 将可迭代对象转换为元组
#		（3）str(obj)				# 将obj对象转换为字符串（数据类型强转）
# 		（4）len(sub)				# 返回序列或集合的长度（可用于列表/元组/字符串）
# 		（5）max(sub)				# 返回序列或集合中最大值（可用于列表/元组/字符串）
# 		（6）min(sub)				# 返回序列或集合中最小值（可用于列表/元组/字符串）
# 		（7）sum[iterable, start]	# 返回序列的总和：（可选参数）start表示从该值开始累加，默认值0。
#		（8）sorted(iterable, key=None, reverse=False)		# 返回排序后的列表。区别：列表的内建方法sort()实现列表原地排序，而sorted()是返回一个排序后的【新列表】。
#		（9）reversed(sequence)		# 返回逆向迭代序列的值。区别：列表的内建方法reverse()实现原地翻转，而reversed()是返回一个翻转后的【迭代器对象】。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.4、四种内建的数据结构：列表、元组、字典、集合

# Python 有四种内建的数据结构：列表、元组、字典、集合
#		<1 列表 list []>
#		<2 元组 tuple (,)>
#		<3 字典 dict {键值对}>
#		<4 集合 set {}>
#
#		<5 字符串 string>
#		<6 序列 sequence>
############################################################################################
# <1 列表 list []> ———— 方括号
# 	列表初始化1：list_temp = ['Python', 'Elephant', 'Penguin']
# 	列表初始化2：list_temp1 = list("Fish delicious")		# 将字符串的每个字符存放到列表中。
# 	列表初始化3：list_temp2 = list((1,2,3,4,5,6))			# 将元组中的每个元素迭代存放到列表中。
#	列表初始化4：list_temp3 = list([list_temp])				# 将可迭代对象转换为列表
#		（1）列表可以存放任何类型的数据，包括：整型、字符串、浮点型、列表、空列表等等。
# 		（2）通过索引值[]获取列表元素：list_temp[1]
#		（3）[a, b]：只包含开始位置a，但不包含结束位置b。	例如：list_temp[0:2]
##########################################
list_temp = [1, '小甲鱼', 3.14, [1,2,4], []]		# 列表初始化
print('列表：', list_temp)
# 向列表添加元素
list_temp.append('rice')		# append()：在列表末尾 - 增加(只能一个)元素。
list_temp.extend([7, 1, 9])		# extend()：在列表末尾 - 添加列表(可实现一次添加多个元素)。
list_temp.insert(1, 0)			# insert()：在列表的任意位置插入元素。第一个参数表示列表中带插入的位置，第二个参数表示带插入的元素。
# 从列表删除元素
list_temp.remove('小甲鱼')		# remove：删除列表元素，但不能指定位置。
list_temp.pop()					# pop()：弹出列表中的最后一个元素(默认);	pop(k)：弹出索引值 k 对应的元素。
del list_temp[1]				# 删除列表中索引值 k 对应的元素;	del list_temp：删除整个列表
# 备注：del是一个语句，而不是列表的方法，故不必在后边加上()。
print('列表：', list_temp)
##########################################
# 列表分片 ———— "拷贝"原列表得到一个新列表(两者独立)；即新列表改变，原列表保持不变。
# 		list_temp[0:2]		# 获取列表中第一个到第二个元素（步长默认1）
# 		list_temp[:]		# 获取整个列表（步长默认1）
# 		list_temp[2][1]		# 获取列表中的列表元素
#		list_temp[::-1]		# 倒序输出列表中所有元素
# 备注：第一个参数（起点）默认0，第二个参数（终点）默认最后一个元素。第三个参数（步长）默认1，正数表示从前向后，负数则相反。
##########################################
temp_count = list_temp.count(3.14)		# count():计算该元素在列表中出现的次数
temp_index = list_temp.index(3.14)		# index():返回该元素在列表中的位置
temp_reverse = list_temp.reverse()		# reverse():将整个列表原地翻转
# temp_sort1 = list_temp.sort()						# sort():对列表的元素进行（从小到大）排序，默认值sort(reverse=False)
# temp_sort2 = list_temp.sort(reverse=True)			# sort(reverse=True):对列表的元素进行（从大到小）排序

############################################################################################
# <2 元组 tuple (,)> ———— 圆括号+逗号
# 	元组初始化1：tuple_temp = ('Python', 'Elephant', 'Penguin')
#	元组初始化2：tuple_temp1 = tuple([tuple_temp ])		# 将可迭代对象转换为元组
#		（1）逗号是元组类型的关键，圆括号只是起到补充的作用。	【例如】整型：temp1 = (1)		元组类型：temp2 = 1,2,3
# 		（2）逗号是必须的，圆括号也是必须的。					【例如】元组类型：temp3 = (1,)
#		（3）元组和列表十分类似。区别：列表可以任意修改列表中的元素，但元素（与字符串一样）定义后不可修改元组中的元素，否则报错。
# 		（4）由于元组是不可改变的，但下面几种方法可以直接应用在元素上：拼接操作符+重复操作符+关系操作符+逻辑操作符+成员关系操作符。
# 用方括号 - 来访问元组元素：		tuple_temp[2]
# 用分片 - 来复制元组元素：		tuple_temp[2:]
##########################################
# 更新和删除元素 ———— 元组是不可改变的，是列表分片的形式拷贝可以 ———— 通过拷贝现有的字符串构造一个新的字符串的方式
tuple_temp = ('Python', 'Elephant', 'Penguin')
tuple_temp1 = tuple_temp[:2] + ('小甲鱼',) + tuple_temp[1:]
print('元组:', tuple_temp1)

############################################################################################
# <3 字典 dict {键值对}> ———— 花括号	
# 	字典初始化1：dict_temp1 = {'key1': value1, 'key2': value2}
# 	字典初始化2：dict_temp2 = dict((('key1', value1), ('key2', 2), ('key3', 2), ('key4', 2)))
# 		（1）键/值对: 用冒号分割（后面需要一个空格）
#		（2）而各个对之间: 用逗号分隔；
#		（3）每一对键值组合称为【项】
# 		（4）键必须独一无二，而值可以取任何数据类型，但必须是不可变的。（如：数字/字符串/列表/元组/字典）
# 		（5）直接给字典的键赋值：如果键存在，则改写对应的值；如果不存在，则自动新增一个键并赋值。
# 字典和序列不同，序列讲究顺序，字典讲究映射，但不讲顺序。
# 字典是Python中唯一的映射类型。【映射】指两个集合之间的元素存在'对应'关系。
dict_temp = {1: 1, 'str2': 'str', 'list3': [1, 'list'], 'tuple4': (1,), 'dict5': {'dict': None}}	
del dict_temp['dict5']				# 通过键索引直接删除一个键值对：key-value pair
dict_temp['add3'] = {1: 'value'}	# 增加一个键值对：key-value pair
##########################################
dict_keys = dict_temp.keys()		# keys()：用于返回字典中所有的键
dict_values = dict_temp.values()	# values()：用于返回字典中所有的值
dict_items = dict_temp.items()		# items()：用于返回字典中所有的键值对（项）
##########################################
dict_get1 = dict_temp.get('key1')			# get()：访问字典项。若键不存在，则返回默认值：None。
dict_get2 = dict_temp.get('key1', '木有')	# get()：访问字典项。若键不存在，则返回默认值：'木有'。
dict_num = 3 not in dict_temp				# 判断键（3）是否在字典中
##########################################
dict_temp.pop(1)					# pop()：弹出给定键对应的值（删除该键值对）
dict_temp.popitem()					# popitem()：弹出最后一个项
print('字典：', dict_temp)
dict_temp3 = dict_temp.copy()		# copy()：复制字典
dict_temp3.clear()					# clear()：清空字典中所有的项
############################################################################################

# <4 集合 set {}> ———— {}
# 	集合初始化1：set_temp1 = {1,2,3,4,5,4,3,2,1}
# 	集合初始化2：set_temp2 = set([1,2,3,4,5,4,3,2,1])
# 		（1）集合具有唯一性，即集合中相同的参数将只保留一个；	输出结果：set_temp1 = {1,2,3,4,5}
# 		（2）集合是无序的（集合中的元素初始化后会乱序显示），故不能索引集合中的任何一个元素，但可以通过循环迭代将数组读出来；
# 成员关系操作符（in/not in）判断元素是否在集合中：0 in set_temp1
##########################################
set_temp = {1, 2, 3, 4, 5, 4, 3, 2, 1}
# frozenset(set_temp )		# 将集合元素冰冻起来，即不能增加或删除集合中的元素
set_temp.add(9)				# add()：添加集合元素
set_temp.remove(2)			# remove()：删除集合元素
############################################################################################
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

5.5、字符串（string）

# <5 字符串 > ———— 单引号/双引号/三引号
# 	字符串初始化：str_temp = '123456789'
# 		（0）C语言用单引号表示字符类型，用双引号表示字符串类型。
#		（1）Python中没有字符（char）类型。对于Python而言，字符就是长度为1的字符串。
#		（2）字符串和元组一样，即字符串定以后不可修改其中的字符（如：赋值），否则报错。
#		（3）通过拼接原字符串的各个部分得到新字符串的方式，原字符串未改变，而是构建了新字符串。
#		（4）由于字符串是不可改变的，但下面几种方法可以直接应用在字符串上：拼接操作符+重复操作符+关系操作符+逻辑操作符+成员关系操作符。
# 用方括号 - 来访问字符串元素：		str_temp[2]
# 用分片 - 来复制字符串元素：			str_temp[2:]
##########################################
str1 = 'I love delicious food.'
str2 = str1 + str1[:6] + ' ' + '插入的字符串' + str1[6:]
print('字符串：', str2)
##########################################
str2_count = str2.count('love', 0, 30)		# count():查找子字符串（在自定义区间内）出现的次数
str2_find = str2.find('love', 0, 30)		# find():查找子字符串在该字符串的位置（返回第一个字符的索引值，否则返回-1）
str2_index = str2.index('love', 0, 30)		# find():查找子字符串在该字符串的位置
str2_replace = str2.replace('food', 'noodles')		# replace():替换指定的字符串

str2_join1 = '*'.join('Eating')						# join():以字符串(*)作为分隔符，插入到字符串的每个字符之间
str2_join2 = '_'.join({'I', 'love', 'Eating'})		# join():以字符串(_)作为分隔符，插入到集合中的每个元素之间（出现乱序输出）
print('插入字符join *：', str2_join1)
print('插入字符join _：', str2_join2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.5.1、格式化字符串 format()

# <5.1 格式化字符串 format()> ———— 用变量的值代替格式符
# 		接收位置参数{0} + 关键字参数{b}（注意：点运算符）
# 		如果位置参数与关键字参数一起使用，那么位置参数{0}必须在关键字参数{b}之前，否则报错。

format_temp1 = '{0} 不喜欢 {1}' .format('猫', '吃白菜')
format_temp2 = '{a} 不喜欢 {0}' .format('吃白菜', a='猫')
format_temp3 = '{{a}}' .format('不打印')		# 输出结果：'{0}'
# 位置参数'不打印'没有被输出，因为{0}的特殊功能被外层的大括号{}剥夺。
1
2
3
4
5
6
7
8

5.5.2、格式化操作符 %

# <5.2 格式化操作符 %> ———— 字符串独享的操作符
#		%c —————— 格式化（整数转）字符（串）及其ASCII码		例如：print('%c' % 97)			输出结果：'a'
#		%s —————— 格式化（数字转）字符串						例如：print('%s' % 97.12)		输出结果：'97.12'
#		%o —————— 格式化（整数转）无符号八进制数				例如：print('%o' % 97)			输出结果：'141'
#		%d —————— 格式化（整数/浮点数转）十进制数				例如：print('%d' % 97.12)		输出结果：'97'
#		%x —————— 格式化（整数转）无符号十六进制数				例如：print('%x' % 97)			输出结果：'61'
#		%f —————— 格式化浮点数（可指定小数点后的精度）			例如：print('%5.1f' % 27.658)	输出结果：'27.7'
#		%e —————— 用科学记数法格式化浮点(等同 %E)				例如：print('%.2e' % 148500000.123456)		输出结果：'1.49e+08'
1
2
3
4
5
6
7
8

5.5.3、转义字符 \

# <5.3 转义字符 \>
#		\' ———— 单引号			\r ———— 回车符
#		\" ———— 双引号			\f ———— 换页符
#		\a ———— 发出系统响铃声	\o ———— 八进制代表的字符
#		\b ———— 退格符			\x ———— 十六进制代表的字符
#		\n ———— 换行符			\0 ———— 表示一个空字符
#		\t ———— 横向制表符TAB	\\ ———— 反斜杠
#		\v ———— 纵向制表符			
1
2
3
4
5
6
7
8

6.1、函数：def

# <函数 Func> —— def hello(a, b=1, c=2)
#		（1）形参 - 形式参数：函数创建并定义过程中小括号里的参数
# 		（2）实参 - 实际参数：函数被调用的过程中传递进来的参数
# 1、普通参数：又叫位置参数。即未指定形参变量名的参数。		例如：hello(a, b)
# 2、关键字参数：在函数传入实参时指定形参的变量名。			例如：hello(a=0, b=1,, c=2)
# 3、默认参数：在函数定义时就赋予了默认值的参数。				例如：def hello(a=0, b=1, c=2)
#####################
# 4、收集参数（元组）：当需要传入元组（多个参数），需要在参数前加上星号（*）。即C语言中用指针传数组/结构体。
#		例如：def test(*params, c=1)		# 调用：params = (1, 2);		test(*params)
# 5、收集参数（字典）：当需要传入字典（多个参数），需要在参数前加上两个星号（**）。
#		例如：def test(* *params, c=1)		# 调用：params = {'a': 1, 'b': 2};		test(* *params)
#####################
# return:可以利用列表/元组打包多种类型的值返回。		# 例如：return [1, '小甲鱼', 3.14]    or    return 1, '小甲鱼', 3.14
# 如果没有return语句，系统将默认返回None。故Python中的函数都有返回值。
##############################################
def hello(a, b = 1, c = 2):
	print('Hello', a+b+c)
	return [1, '小甲鱼', 3.14]
print(hello(3, 7, 10))			# a = 3;	b = 7;		c = 10;
hello(25, c = 24)				# a = 25;	b = 1;		c = 24;
hello(c=50, a=100)				# a = 100;	b = 1;		c = 50;
# 备注1：函数的输入参数没有顺序要求：在函数时，a在c之前定义，但可以在a之前【指定参数c】进行赋值。
# 备注2：默认参数需要排布在所有参数的末尾。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6.2、类和对象：class

# <类和对象> ———— 对象=属性+方法(变量+函数)
# 		（1）对象的特征叫做'属性'；			对象的行为叫做'方法'。
#		（2）【创建一个对象】，也叫【类的实例化】，被实例化的对象叫作【实例对象】
# 		（3）【类名】约定大写字母开头；		【函数】用小写字母开头
# 每个对象的方法都会有一个self参数：由于同一个类可以生成无数对象，self就相当于在很多个相同的对象中表面身份。相当于C++的this指针。
# 在Python中，（默认）对象的属性和方法都是公开的，可以直接通过点操作符(.)进行访问。
# 		定义私有变量："__变量名/函数名"		例如：p.__name		# 其中p是实例对象
# 		访问私有变量："_类名__变量名"			例如：p._Pearson__name
##############################################
class Pearson:				# 类名：Pearson
	def __init__(self, name):
		self.name = name
		
	def kick(self):			# 函数：kick
		print('%s是我, 谁敢打我？' % self.name)


p = Pearson('西瓜')			# 类的实例化，p为实例对象
p.kick()					# 调用实例对象的方法
# 备注：class（类）、类对象（Pearson）、实例对象（p）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.3、继承（多重继承）

# <继承>
# 		被继承的类：	基类/父类/超类(Fish)
# 		继承者：		子类(Shark)	———— 子类可以继承它的父类的任何属性和方法。
# 		<多重继承>:	即同时继承2个以上的类对象，若类之间有继承，则子类必须在前，否则报错。提示：如非必要，请尽量避免使用，有时候会出现不可预见的BUG。
# 备注：若子类中定义的方法或属性与父类中有同名，则子类会自动覆盖父类对应的方法或属性。
# super()函数：能自动找到（继承的）基类的方法，而且默认已经传入了self参数（即无需再输入self，故没有显示）。
##############################################
class Fish:				# 定义一个类对象Fish
	def __init__(self):
		self.move_forward = True


class Shark(Fish):				# 定义一个类对象Shark，并【继承】父类对象Fish
	def __init__(self):
		super().__init__()		# 等同于Fish.__init__(self)
		self.hungry = True

class Ocean(Shark, Fish):		# 定义一个类对象Ocean，并【多重继承】父类对象Fish、Shark
	print('海中有鱼，也有鲨鱼')	# 若类之间有继承，则子类必须在前，否则报错。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7、异常处理：raise + with + assert + try

# <异常处理>
# （1）try...except语句 ———— 如果try语句有异常，则执行except语句，打印自定义消息提示。
# （2）Try...finally语句 ———— 无论异常发生与否，都将执行 finally 语句。
# （3）Try...except...finally语句 ———— 如果try没有异常，则只执行finally语句。如果try有异常，则同时执行except与finally语句。
# （4）with语句（与open()一起使用） ———— with语句将在文件打开后自动关闭文件。
# （5）raise语句引发异常（即已知在什么情况下会发生异常，异常后报错提示）
# （6）assert(1 > 4) 		# assert语句：断言该语句失败，失败后报错提示：AssertionError
##############################################
while 1:
	try:
		with open('1.txt') as f:
			print('我没错，我永远是对的')
	except FileNotFoundError:
		print('出错啦')
	finally:
		print('回家收衣服')
# if 1/0
# 	 raise ZeroDivisionError('除数不能为0')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8、类型判断：isinstance() + type()

#############################################################
# 判断实例对象是否是已知的类型
# 		方法一：isinstance(object, classinfo)
#		方法二：type(object) == classinfo
#############################################################
a = 9.0
print(type(a) == int)			# False
print(type(a) == float)			# True

print(isinstance(a, int))		# False
print(isinstance(a, float))		# True

print(isinstance(a, (str, float, int, list)))   # 只需要属于元组中的任意一个，即返回True

1
2
3
4
5
6
7
8
9
10
11
12
13
14

type与isinstance的区别

#############################################################
# type()：				不会认为子类是一种父类类型，不考虑继承关系。
# isinstance()：		会认为子类是一种父类类型，考虑继承关系。
# 如果要判断两个类型是否相同推荐使用：isinstance()
#############################################################
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
 
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
 
class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course


p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

print(isinstance(p, Person))		# True
print(isinstance(s, Person))		# True
print(isinstance(t, Person))		# True

print(type(p) == Person)		# True
print(type(s) == Person)		# Fasle
print(type(t) == Person)		# Fasle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

---

备注1：Pycharm使用教程

Pycharm最全中文教程 入门教程 完整版PDF

备注2：Pycharm常用快捷键