Python基础知识
文章目录
- 推荐看系列
-
- 1、模块
-
- 1.1、基本模块：math、sys、time、random、os
- 1.2、 dir、__doc__、help()
- 1.3、if __name__ == '__main__'
- 1.4、读取文件open()
- 1.5、导入模块的四种方法
- 2、输入输出
-
- 2.1、单行输入
- 2.2、多行输入
- 2.3、单引号、双引号、三引号
- 3、基本概念
-
- 3.1、E计数法、获取数据类型
- 3.2、算数操作符、逻辑操作符、连接操作符、重复操作符、成员关系操作符
- 4、循环语句
-
- 4.1、for、while
- 4.2、continue、break、return、pass、global、None
- 5、数据类型 + 数据结构
-
- 5.1、数据类型：整型、浮点型、字符串型、布尔型、复数类型
-
- 5.1.1、数据类型强转
- 5.1.2、工厂函数
- 5.2、引用 —— 赋值与复制操作的区别
- 5.3、序列 —— 序列常用的BIF
- 5.4、四种内建的数据结构：列表、元组、字典、集合
- 5.5、字符串
-
- 5.5.1、格式化字符串 format()
- 5.5.2、格式化操作符 %
- 5.5.3、转义字符 \
- 6.1、函数
-
- 6.2、类和对象
- 6.3、继承（多重继承）
- 7、异常处理
- 备注：Pycharm常用快捷键
推荐看系列
强烈推荐看：Python 基础（一）：入门必备知识
推荐看：Python基础知识点总结
介绍：Python是一门既简单又功能强大的编程语言，它注重的是如何解决问题而不是编程语言的语法与结构。
详细请看：＜A Byte of Python＞+＜小甲鱼-零基础入门学习Python＞
# Python 从0开始计数，而非从1开始（MATLAB）。
# 同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。
# Python的语句末尾不需要分号(;) ———— （1）如果想要多个语句写在同一行，那么你需要使用分号(;)，但强烈不建议。
# ———— （2）如果想要多个语句写在同一行，那么你需要使用逗号(,)，建议（但赋值语句不可用）。
1、模块
1.1、基本模块：math、sys、time、random、os
import math
import sys
import time
import random
import os
##############################################
# 【math库】仅支持整数和浮点数计算，不支持负数
# math库共提供如下函数：
# 1、四个常数
# （1）math.pi # 圆周率：3.1415926...
# （2）math.e # 自然对数：2.718...
# （3）math.inf # 正无穷大，负无穷大：-math.inf
# （4）math.nan # NAN（Not A Number）
# 2、44个函数
# （1）16个数值表示函数 （2）8个幂对数函数
# （3）16个三角对数函数 （4）4个高等特殊函数
#####################
# 【sys模块】路径搜索：新增导入模块的路径。
# sys.path.append('文件路径') # 用sys模块的path变量，在（搜索路径）列表的末尾新增一个路径。
# 备注：系统默认添加当前文件路径。
sys.path.append('C:\\Users\\pc\\Desktop')
sys_temp1 = sys.path
# import add_1 # 虽然添加了搜索路径，在导入模块时系统仍会报错提示：No module named.但可以正常运行和计算。
# sys_temp2 = add_1.def_add(22, 2) # add_1是自定义的模块（.py） def_add是自定义的函数
#####################
# 【time模块】
time.sleep(2) # 用time模块的sleep()函数：暂停2秒钟
t1 = time.localtime() # 用time模块的localtime()函数：返回一个时间元组，包括九个元素。
# 年/月/日/时/分/秒/毫秒/微妙/纳秒。1s=1000ms.1ms=1000微妙.1微妙=1000纳秒.
#####################
# 【random模块】
print('随机数：', random.randint(0, 9)) # 用random模块的randint()函数：生成随机数。(在0~9之间随机生成一个整数。)
#####################
# 【os模块】Operating System（操作系统）
path = r'C:\Users\pc\Desktop'
print('工作目录：', 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系统自带的计算器
##############################################
python的math库函数汇总
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.3、if name == ‘main’
# if __name__ == '__main__' # 可以等同理解为C++中的int main()
# （1）在作为程序运行的时候，__name__属性的值是'__main__'。 # 即其本身作为主函数
# （2）作为模块导入的时候，__name__属性的值就是该模块的名字。 # 即其作为外部库使用，且只调用函数，忽略其函数调用（若有）。
# 备注：该方法让Python知道导入的模块是作为程序运行韩式导入到其他程序中。
# 避免导入的模块中本身即有函数定义也有函数调用，进而导致调用时出现BUG（例如：出现双重调用现象）
1.4、读取文件open()
# 读取文件
# f = open('test.txt', 'w') # （1）读取文件模式：读模式('r')、写模式('w')或追加模式('a')。
# f = open(test.txt) # （2）直接读取文件：打开一个文件，并返回一个【文件对象】。
# 关闭文件
# f.close() # 调用文件对象的方法
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 *
##############################################
2、输入输出
2.1、单行输入
# 输入：input('请输入：') # 备注：只能单行输入
# 输出：print('Yes', 1)
2.2、多行输入
# 导入多行数据
if 0:
lines = int(input('请输入变量的个数(输入0行，跳过函数)：'))
else: # 不执行
lines = 0
text = ''
# text = [] # 将每一行的数据按字符分开保存到列表中
for ii in range(lines):
# text += input() # 将所有输入行的字符拼接到同一个变量
text += input() + '\n' # 按行输入，按行输出
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.')
3、基本概念
3.1、E计数法、获取数据类型
# E计数法（E或e都可以）：1.5万 = 1.5e4 # 其中，E的意思就是指数10，E后边的数字就是10的多少次幂。
# 获取数据类型：（1）直接获取：type()函数
# （2）对比获取：True/False = isinstance（待确定类型数据，指定数据类型）
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）"成员关系操作符"只能判断一个层次的成员关系；（2）字符串和列表都可以使用"连接操作符"和"重复操作符"
##############################################
# Python中的 * 与 ** 操作符的两种用法
# （1）用做运算符，即*表示乘号，**表示次方。效果等同：x**2 == numpy.power(x, 2)
# （2）用于指定函数传入参数的类型的。（详细请看函数）
# *用于参数前面，表示传入的多个参数将按照元组的形式存储，是一个元组；
# **用于参数前则表示传入的(多个)参数将按照字典的形式存储，是一个字典。
##############################################
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.") # 跳出循环后执行
4.2、continue、break、return、pass、global、None
# continue语句： 跳过当前循环块中的剩余语句，然后继续进行下一轮循环；
# break语句： 停止并跳出当前循环体；
# return语句： 跳出函数并返回一个值；
##############################################
# pass语句 在Python中表示一个"空"的语句块；
# global语句： 全局变量声明。如：global x = 3
# None 表示"空"的特殊类型。如：return None
5、数据类型 + 数据结构
5.1、数据类型：整型、浮点型、字符串型、布尔型、复数类型
# 数据类型：整型(int)、浮点型(float)、布尔类型(bool)、字符串类型(str)、复数类型等
# Python的变量在使用时不需要声明或定义数据类型，直接赋值即可。系统会自动依据赋值内容给定数据类型。
# 区别：（1）Python有字符串类型，但没有char字符类型。（2）没有switch语句。
5.1.1、数据类型强转
# 数据类型强转：int()、float()、str()
5.1.2、工厂函数
# 内置函数（Built-in Functions, BIF）转换为工厂函数：
# type(int) # class类型
# type(int()) # int 类型 # 同理：int()/float()/str()/list()/tuple
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)
5.3、序列 —— 序列常用的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()是返回一个翻转后的【迭代器对象】。
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()：删除集合元素
############################################################################################
5.5、字符串
# <5 字符串 string> ———— 单引号/双引号/三引号
# 字符串初始化：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)
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}的特殊功能被外层的大括号{}剥夺。
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'
5.5.3、转义字符 \
# <5.3 转义字符 \>
# \' ———— 单引号 \r ———— 回车符
# \" ———— 双引号 \f ———— 换页符
# \a ———— 发出系统响铃声 \o ———— 八进制代表的字符
# \b ———— 退格符 \x ———— 十六进制代表的字符
# \n ———— 换行符 \0 ———— 表示一个空字符
# \t ———— 横向制表符TAB \\ ———— 反斜杠
# \v ———— 纵向制表符
6.1、函数
# <函数 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：默认参数需要排布在所有参数的末尾。
6.2、类和对象
# <类和对象> ———— 对象=属性+方法(变量+函数)
# （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）
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('海中有鱼，也有鲨鱼') # 若类之间有继承，则子类必须在前，否则报错。
7、异常处理
# <异常处理>
# （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
##############################################
try:
with open('1.txt') as f:
print('我没错，我永远是对的')
except FileNotFoundError:
print('出错啦')
finally:
print('回家收衣服')
# if 1/0
# raise ZeroDivisionError('除数不能为0')
备注：Pycharm常用快捷键
| Pycharm常用快捷键 | 说明 |
|---|---|
| Ctrl+C | 强制终止正在运行的程序 |
| Ctrl+N | 查找所有的类的名称 |
| Ctrl+/ | 对选择的行注释（或取消注释） |
| Ctrl+B/鼠标左键 | 点击变量转到方法定义处 |
| Ctrl+Tab | 在窗口间进行切换 |
| Ctrl+Z | 撤销键入 |
| Ctrl+Shift+Z | 恢复键入 |
| – | – |
| F7 | 单步执行（进入函数） |
| F8 | 单步执行（跳出函数） |
| F9 | 运行到下一个断点 |
| Shift+F9 | 调试Debug |
| Shift+F10 | 运行RUN |
| – | – |
| Ctrl+Shift+up | 快速上移某一行 |
| Ctrl+Shift+down | 快速下移某一行 |
| Ctrl+Alt+左箭头 | 返回到前一个光标的位置 |
| Ctrl+Alt+右箭头 | 返回到后一个光标的位置 |
| Ctrl+Shift+F7 | 高亮选中的单词。F3移动到下一个，Esc取消高亮 |
| Pycharm 常用快捷键 |