‌Python在AI场景深度融合、实时数据处理需求增长、物联网与边缘计算拓展等方向发展趋势向好。Python在AI领域的应用从基础工具转向实际场景落地，企业急需掌握大模型微调、轻量化部署的开发者，同时AutoML工具降低了非专业背景开发者介入门槛，但实战经验仍被优先考虑。电商平台用户行为分析、金融风控等领域要求开发者掌握PySpark、Dask等工具进行TB级数据高效处理，同时需将分析结果转化为业务决策支持。 智能工厂、智慧城市等场景推动Python在边缘设备数据采集、协议转换等领域的应用，相关岗位需求逐步增长。

在学习Python的过程中，建议优先选择包含实战项目的课程，如AI场景的大模型微调案例、实时数据处理模拟项目等，避免纯理论教学。同时关注Python社区版本更新和工具迭代，课程需及时纳入新应用场景(如当前Python 3.14.0版本特性)。建议每天手写代码，从简单逻辑开始积累，利用python -i命令实时测试片段。

参考原文：

零基础学Python入门教程

Python入门，详细基础教程，零基础入门，详细图文

Python 速览：Python 速览 — Python 3.14.0 文档

Python标准库：Python 标准库 — Python 3.14.0 文档

简介、配置

Python它是一种直译式，面向对象，解释式的脚本语言。它和Java，C/C++，Go语言一样都是高级语言，但由于它是解释式语言，所以运行速度会比Java，C/C++等语言慢（虽说隔壁Go也是解释式语言，但比它快很多）。不过任何事物有利也有弊，Python因为自身携带了许多库（如：OS、TCP、Urllib、Trutle)，语法简单，第三库也有很多（如飞机大战所需的 pygame)，所以被称为胶水语言。

应用范围及优缺点

系统运维、图形处理、数学处理、文本处理、数据库编程、网络编程、web编程、多媒体应用、pymo引擎、黑客编程、爬虫编写、机器学习、人工智能等。

优点：免费开源、无社区限制、可开发应用面广、可跨平台、功能强大、自身携带模块多、第三方模块多、语法简单，代码量少可实现多功能等。
缺点：运行速度远比C/C++等语言要慢等。

安装与配置Python IDE

IDLE官网：https://www.python.org/downloads/。此处下载的是[Python 3.13.9](https://www.python.org/downloads/release/python-3139/)，安装包地址：[Windows installer (64-bit)](https://www.python.org/ftp/python/3.13.9/python-3.13.9-amd64.exe)

双击下载的exe文件，选择自定义安装，记得选择ADD TO PATH，一直next，安装成功后在Command(Cmd)中输入python会提示：

1
2
3
C:\Users\hp>python
Python 3.13.9 (tags/v3.13.9:8183fa5, Oct 14 2025, 14:09:13) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

如果失败可以尝试一下再次双击下载的exe文件，点击Repair，修复完后重试通常都能成功。

IDEA配置python插件时在设置里没有找到，手动访问 JetBrains 插件市场点击按钮Install to Intelly lDEA 2025.1.3安装成功的。之后New Project 和 New Module wizards都添加了Python module type。New Project → python 界面中的 Base interpreter自动选择了安装好的`D:\IDEA\Python313\python.exe。

参考官网地址：https://www.jetbrains.com/help/idea/plugin-overview.html

Python基础

注释方式

单行注释以 # 开头，通常用于对单行代码进行说明，注意，#号和注释内容一般建议以一个空格隔开。

多行注释有两种方式：连续使用多个单行注释或使用三重引号（’’’ 或 “””）。

数据类型

Python语言在定义变量时，不需要指定变量的数据类型，Python程序会根据变量值，自动确定变量类型。

数据类型(数字)

在Python中，数字数据类型有 int、float、bool（布尔型）、complex（复数）。学过C语言的人需要知道 Python 中浮点类型只有单精度float，不要以为保留两位小数的数就是双精度类型(double)，在Python中无论多少位小数它的数据类型都是float。
可以用type()函数判断该数字的数据类型。也可以用isinstance(num, type)函数来判定，结果返回True代表你认为的数据类型是正确的，False就代表错误。

算数运算符

在程序前添加 import math ，可将Python内置函数库加载到程序内。内置函数库网址：math — 数学函数 — Python 3.13.0 文档

1
2
3
4
5
6
7
8
在Python中，运算符有：加（+）、减（-）、乘（*）、除（/）、乘方（**）、取模（%）、整除（//）
+:加法，两个变量相加求和
-:减法，两个变量相减求差
*：乘法，变量相乘求积
/：除法，变量相除求商
%：取模，得到除法结果第一位余数
**：次方，求变量（a）的n次幂->(a)ⁿ，可以用pow()函数代替
//：整除，取除法后的整数部分

与数字数据类型来结合使用：

1
2
3
a = 1314
b = 521
print(a+b,a-b,a*b,a/b,a%b,a**b,pow(a,b),a//b,)

数据类型(字串符：string)

如果想换行转义输出，可在要转义的字串符之间加个\n（PS：反斜杠\是特殊转义字符），但在字串符前加个 r 将会是原字串符输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
a = 'Hello','LWL'
b = 'Hello''LWL'    
#注意字串符a与b的区别，如果有逗号，那么输出时将会是两个字串符一起输出，如果没有输出将会两个字串符相互结合输出
c,d = 'Hello','LWL'
print(a) # ('Hello','LWL')
print(b) # HelloLWL
print(c,d) # Hello LWL
print(c+d) # HelloLWL
print(b[0:-2]) # HelloL
print(c[0:-3]) # He
print(d[0:-1]) # LW
print(c*2,d*2)# 各输出两次 HelloHello LWLLWL
print((c+d)*2)# 结合输出两次 HelloLWLHelloLWL
print('Hello,\nLWL') # Hello,换行输出LWL
print(r'Hello,LWL')# 加了r后转义字符失效 Hello,LWL
e='Love LWL 1314'
print(e[0],e[5]) # 输出指定索引位置的字母 L L
# Python与C语言字串符不同的地方在于Python字串符是不可以被改变的，如果向一个指定索引赋值，那么将会错误
print(e[0],e[-2],e[3]) # L 1 e

三引号跨行字符串
三个连在一起单引号或双引号。

1
2
3
4
5
# """   """          '''   '''
print("""1234abcd.
1234abcd.
1234abcd.""")
# 打印出来是换行的效果

格式化字符串

  1. format方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # format内的参数起始编号以0开始，即花括号引用的0表示第一个参数，1表示第二个参数。
    content = """律回春渐，新元肇启。
    新岁甫至，福气东来。
    金{0}贺岁，欢乐祥瑞。
    金{0}敲门，五福临门。
    给{1}及家人拜年啦!新春快乐，{0}年大吉!""".format(year, name )

    # format还可以根据关键词引用，这种方式就不需要考虑参数在format内的哪个位置，只根据关键词引用。
    message_content = """律回春渐，新元肇启。
    新岁甫至，福气东来。
    金{current_year}贺岁，欢乐祥瑞。
    金{current_year}敲门，五福临门。
    给{receiver_name}及家人拜年啦!新春快乐，{current_year}年大吉!""".format(receiver_name = name, current_year=year)

  2. f-字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # f字符串引用已定义的字符串变量。
    name = "老林"
    year = "虎"
    message_content = f"""律回春渐，新元肇启。新岁甫至，福气东来。金{year}贺岁，欢乐祥瑞。金{year}敲门，五福临门。给{name}及家人拜年啦!新春快乐，{year}年大吉!"""

    # format方法调到用字符串可以直接调用数字，不需要额外进行数字转字符串的操作。
    gpa_dict = {"小明":3.251，"小花":3.869，"小李":2.683,"小张":3.685}
    for name,gpa in gpa_dict.items():
        print("{0}你好，你的当前缋点为:{1}".format(name,gpa))
        
    # 使用 冒号+点+数字+f 来指定浮点数在格式化是保留几位小数。
    gpa_dict ={"小明":3.251,"小花”:3.869，"小李":2.683,"小张":3.685}
    for name,gpa in gpa_dict.items():
        print("{0}你好，你的当前绩点为:{1:.2f}".format(name,gpa))

布尔类型 bool

只有两种值

1
2
真           假
True         False   （区分大小写）

空值类型 NoneType

只有一种值：None

表示完全没有值
None 不是0，不是空字符串””，也不是False。

复合数据类型（列表:List）

在Python中，复合数据类型分别有三种：Tuple（元组）、Set（集合）与List（列表）。这三类中最简单的一类：List（列表）
创建一个列表数据类型方法：变量名称 = ['数值',数值]。列表有序，可重复，可扩展。

在列表的数值内容中，数值可以类型不同，但要注意：除数字以外其他任何数值都必须要用单引号括起（无论是中文还是其他国家语言），而数字数值可以不用单引号括起）。代码实例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a = ['a','b','c',3] #创建两个列表
b = [4,7,'love','to','lwl',',','never','change']
print(a,b) # ['a', 'b', 'c', 3] [4, 7, 'love', 'to', 'lwl', ',', 'never', 'change']
print(len(a)) # 输出 4
print(a[0:1:3]) # 输出指定列表被切割后的指定数据 ['a']
print(b[1:7]) # [7, 'love', 'to', 'lwl', ',', 'never']
print(a[3]) # 输出指定索引搜索的数据 3
print(b[7]) # change
a[0:3]='A','B','C'  #修改列表中指定数据，即可以直接修改
print(a) # ['A', 'B', 'C', 3]
b.append(347) # append()函数用于在制定列表末尾添加新数值
print(b) # [4, 7, 'love', 'to', 'lwl', ',', 'never', 'change', 347]
a[1] = [] # 移除a列表中指定索引数据
print(a) # ['A', [], 'C', 3]
# len()函数用于统计列表数据个数
print('a列表数据个数:',len(a),'b列表数据个数:',len(b)) # a列表数据个数: 4 b列表数据个数: 9
c = [0,1]   # 生成一个嵌入式列表 
d = [2,3]
e = [c,d]
print(e) # [[0, 1], [2, 3]]

复合数据类型（Tuple:元组）

在Python中，元组的语法与列表差不多，不同之处就是元组使用小括号 ()，且括号中元素不能被改变，添加、删除等操作都不能操作，创建元组可以不需要括号；而列表是使用中括号 []。想把列表转换为元组或元组转换为列表，只需要改一下括号即可。元组有序，可重复，不可扩展。

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
# 变量名称 = ('元素',元素)
# 变量名称 = "元素","元素"

# 创建元组实例
a = ('C/c++','Python',2)    # 创建两个元组
b = "Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"
print(a,b) # ('C/c++', 'Python', 2) ('Python菜中菜的菜鸟', 'Love to lxx for Li wenli', 'never change')
# 元组与列表语法相似，所以元组可以与其他元组结合为一个新元组并输出
c = a+b # 相互结合
print(c) # ('C/c++', 'Python', 2, 'Python菜中菜的菜鸟', 'Love to lxx for Li wenli', 'never change')
# 元组也和字串符一样支持+和*运算符
print(len(c)) # 输出c元组内数据个数
print(c*2) # 复制输出
# 元组也和字串符一样支持+和*运算符
print(len(c)) # 输出c元组内数据个数
print(c*2) # 复制输出
# 创建一个空的元组
a = ()
# 如果想删除元组用del
del c
print(c) # Traceback(most recent call last): ……
print(b in ("Python菜中菜的菜鸟","Love to lxx for Li wenli","never change")) # 判断元素是否存在

for c in ("Python菜中菜的菜鸟","Love to lxx for Li wenli","never change",'C/C++','Python',2):
      print(c,) # 迭代输出

元组的内置函数

1
2
3
4
5
6
7
8
a = ['C/C++','Python',2,4]    # 创建列表
b = ["Python菜中菜的菜鸟","Love to lwl for Li wenli","never change"]
c = a+b # 相互结合
c = tuple(c)  # 强制转换为元组
print(len(c)) # 输出列表内数据个数  7
d = ('3','4','7')
print(max(d)) # 输出d元组内最大数值 7
print(min(d)) # 输出d元组内最小数值，max()是判断最大值函数，min()反之 3

复合数据类型（Set:集合）

Set（集合）数据类型是一种无序不重复元素的序列。在Python中，使用大括号 {}或内置函数Set()来创建一个集合（创建一个空集合必须用Set()函数），{} 实质是创建一个空的字典。集合无序，不可重复，可扩展。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
a = {'a','b','c','d','a'} # 创建集合a
print(a) # 因为集合是无序不重复元素序列，所以不会输出多出的a
b = set('sdgsdggfdgdasrfdsf') # 运用Set()函数创建集合b
print(b)
# 判断元素是否在集合内
print('a' in a，'e' in a) # 主要判断a与e元素是否在此集合内，输出True False
# Set也支持数学运算符运算，不同运算符使用范围也不同
a = set('sdfygsyfysdgfsdtfsyhf')
b = set('hgdhsdfsghdvhgsfs')
print(a - b) # {'t', 'y'}
print(a | b) # {'t', 'g', 'y', 'f', 'h', 's', 'd', 'v'}
print(a & b) # {'g', 'f', 'h', 's', 'd'}
print(a ^ b) # {'t', 'y', 'v'}
# 使用关键字add或update来添加新的元素，对于输出结果，对照会发现每次输出都会有不同的新元素输出
b.add('fuck')
b.update('good')
print(b) # {'s', 'f', 'v', 'fuck', 'd', 'h', 'o', 'g'}
# 删除某些元素，可以使用关键字remove，discard或pop(pop会随机删除某些元素)，clear()会全部删除
b = set('abcdefghijk,fuck,abats')
b.remove('f')
b.discard('h')
b.pop()
b.clear()
print(b) # 使用了clear()函数后输出一个空的集合

数据类型(字典:dictionary)

在Python中，字典是另外一种数据储存的可变容器，而且可以存储任何数据类型的数据值对象。键必须为不可变数据类型；即字符串、整数、浮点数等，不能为列表。

创建一个空字典需要用大括号｛｝，在字典中每一个值对用冒号，且每个值需要逗号（,）分隔。

1
2
3
4
a = {key1:value1,key2:value2,key3:value3}
dictionary{key1->value1
                key2->value2
                key3->value3

如果要输出的值字典内没有，那么输出将会显示异常 Traceback (most recent call last):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = {'a':'Python','b':'347','c':'hjgjhfgy'} # 创建一个字典
b = {'a':'HTML/Javascript','b':'Rust'}
# a['a']与a['c']是分别访问并输出字典内对应数据值，与索引方式差不多，而print(b)则负责输出整个字典b内数据。
print(b) # {'a': 'HTML/Javascript', 'b': 'Rust'}
print(a['a'],a['c']) # Python hjgjhfgy
# 想要修改字典内的数据很简单，与前面的复合数据类型修改方式一样，不过要注意字典修改数据时修改对象填的不是数字，而是对应的名称。
a['c'] = 'Perl' # 添加或更新键值对的方法：字典名[“键”] = “值“
print(a['a'],a['c']) # Python Perl
print('a' in a)# 判断键是否存在字典里面：“键”in 字典名
del a['a'] # 删除键与对应的值：del 字典名[“键”], 如果键不存在，指令会报错。
# 清除字典数据与集合一样，使用clear()函数，然而删除的话就需要用到del语句
a.clear() # 清除字典所有数据
print(a) # 输出 {}
del a # 删除字典
print(a) # Traceback (most recent call last): NameError: name 'a' is not defined

返回字典的键、值、键值对的方法：

1
2
3
temperature dict.keys()     # 所有键
temperature dict.values()    # 所有值
temperature dict.items()     # 所有键值对

编程规则

匈牙利命名法

匈牙利命名法是由Microsoft 程序员查尔斯- 西蒙尼(Charles Simonyi)提出，匈牙利命名法通过在变量名前面加上相应的小写字母的符号标识作为前缀，标识出变量的作用域，类型等这些符号可以多个同时使用，顺序是先m_（成员变量）， 再指针，再简单数据类型，再其它 。如c_MessageBox

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
属性+类型+描述
属性一般是小写字母+_:
g_:全局变量
m_:类成员变量
s_:静态变量
c_:常量
类型就多了：
b:bool
sz:以零结束的字符串
p:指针
n:整整
dw:双字
l:长整型
无符号:u
函数:fn

驼峰命名法

驼峰命名法包含了小驼峰命名法与大驼峰命名法，顾名思义利用了驼峰命名法来命名变量该变量也会有些高低起伏。

小驼峰命名法：变量名称开头小写，然后后面英文隔一部分后开始大写一个英文字母，如conTent…

大驼峰命名法：变量开头大写，后面每隔一部分英文后就大写一个英文字母，如ConTent，FirstName，MessageBox…

帕斯卡命名法

与大驼峰命名法一样，都是开头大写，后面每隔一部分英文后就大写一个英文字母

输出函数 print

在所有编程语言中，想要输出一组数据值，就必须定义常量与变量。常量嘛，大家就理解为是一个定义名称，且是定死的就行；变量这个东西，它可以是一组数据，一组数字，一组字串符，或者其他的等等。

在Python中，想赋值一个字串符变量，必须要用单引号(‘’)或双引号(“”)包装你要输出的字串符数据值，否则直接赋值的话该写法是不符合语法的（除数字数据类型以外其他数据类型都一样）。

利用单引号(‘’)或双引号(“”)包装并输出

1
2
3
4
5
6
7
8
9
10
11
# 节省字节免得占磁盘，
print('1234abcd')
print("1234abcd")
# 不考虑节省字节
numStrs='1234abcd'
print(numStrs)
# 运用到自定义函数输出
def numStrs():
    print('1234abcd')
numStrs()

输出结合

1
2
3
4
# 字串符结合再输出,用到一个算术运算符：+
a = '1234'
b = 'abcd'
print(a + b) # 1234与字串符abcd就是变量，通过等于号(=)赋值给a与b，然后将a和b传输到print()函数中，之后就可以输出结果了

输入与输出

通过input()函数获取输入的数据值，然后把这组数据赋值给常量a,然后常量a把数据传递给print()函数，最终输出。

1
2
a = input()
print(a)

可以结合算术运算符与float数据类型做一个超简易计算器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = input()
b = input("请输入运算符号")
c = input()
if (b == '+'):
    print(float(a)+float(c))
elif (b == '-'):
    print(float(a)-float(c))
elif (b == '*'):
    print(float(a)*float(c))
elif (b == '/'):
    print(float(a)/float(c))
elif (b == '%'):
    print(float(a)%float(c))
elif (b == '**'):
    print(float(a)**float(c))
elif (b == '//'):
    print(float(a)//float(c))

input()函数也可以和其他数据类型相结合，如集合，列表，元组等藕合数据类型，也可以与字典，字串符等数据类型结合使用。

代码原理：通过运用input()函数对创建的各个数据类型与其对应的常量赋值，并传递给相对应的print()函数，最后输出结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
a = (str(input()))
b = (list(input()))     # 创建一个空列表
c = (tuple(input()))    # 创建一个空元组
d = (set(input()))      # 创建一个空集合
e = {}  #创建一个空字典
e_ElementName = input("请输入名称:")
e_ValueContent = input("请输入内容:")
e[e_ElementName] = e_ValueContent
print("您输入的字串符:",a)
print("列表结果:",b)
print("元组结果:",c)
print("集合结果:",d)
print("字典结果:",e)

判断语句

if、if…else、if…elif…else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
me =int(input())
wl = int(input())
# if的用法
if me < wl :
   print("Lwl赢了")
if me > wl :
   print("我赢了")
# if…else的用法
if me < wl :
   print("WL赢了")
else :
   print("我赢了")
# if…elif…else用法
if me < wl : 
   print("WL赢了")
elif me == WL :
  print("打平手了")
else :
   print("我赢了")

关键词 or、and和not

优先级顺序 not ——> and ——> or，也可以使用括号改变运算顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
me = int(input())
wl = int(input())
# and的用法
if me  == 520 and wl == 520 :
   print("就知道你爱我。")
elif me == 1314 and wl == 1314 :
   print("我会一生一世爱你，不仅与你白头到老，而且never change。")
else :
   print("这不是你的真心话。")
# or的用法
if me == 520 or wl == 520 :
   print("就知道你爱我。")
else :
   print("这不是你的真心话。")
# 非（not）  操作对象为True，则返回Flase；操作对象是Flase，则返回True。
not(x>5 and (x<10 or x==12))

操作运算符

1
2
3
4
5
6
< ：小于，用于判断变量是否小于常量
> ： 大于，用于判断变量是否大于常量
>= ：大于或等于，用于判断变量是否大于或等于常量
<= ：小于或等于，用于判断变量是否小于或等于常量
== ：等于，用于判断两个常量是否相等
!= :不等于，用于判断两个常量是否不等于
1

循环语句

在Python中，循环语句有for和while。PS:Python中没有do …while循环语句！

for循环

在Python中， for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。（就是按顺序输出常量元素）

1
2
3
4
5
6
7
8
9
10
for 变量 in 顺序:
    声明
# 数字
for i in range(list(8)):
    print(i)
# 字串符
a = '546dsf6d6sf74ds'
# 先通过len()函数获取字串符长度，然后通过for循环与range()函数对其进行遍历与循环处理，最后输出每个长度位置对应的字串符结果。
for i in range(len(a)):
    print(i,':',a[i])

range 表示整数序列

range(5,10)：第一个数字为起始值，第二个数字为结束值，注：结束值不在序列范围内。

range(5,10,2)：range的第三个参数为步长，不指明的时候默认为1

while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
while True:
    me = int(input())
    wl = int(input())
    if me ==520 and wl != 520:
        print('这不是你的真心话')
    elif me > 5 and wl < 7:
        print('我跟你的相遇就像是酸遇上了碱，我们彼此中和，释放出了热与激情。')
        print('我对你的感情就像是钡离子与硫酸根的完美结合，生成了美好的感情沉淀。')
        print('我知道你的未来就像是Li  Na K Ru Cr Ba Ca Sr 的焰色反应一样五彩缤纷。')
    elif me >= 64 and wl <= 103:
        print('我爱你，我会爱你爱到CuSO4 + Ba(OH)2=BaSO4↓+Cu(OH)2 ↓这两个产物无法分离提纯。')
    elif me and wl == 1314:
        print('我夺走了你的电子，请不要生气，我是为了更稳定的跟你结合在一起.')

break 终止当前循环，,使程序跳出循环体。
continue 结束当前循环剩余语句，继续下一轮循环
pass 在Python中是一个空语句，什么都不做，占位语句，它的主要目的是为了保持程序结构的完整性。当你在编写代码时，可能只想先搭建起程序的整体逻辑结构，而暂时不去实现某些细节。在这种情况下，你可以使用pass语句来占位，这样就可以避免因为语句块为空而导致的语法错误。pass语句不会执行任何操作，它只是一个空白的语句块。

函数

Python内置函数

1
2
3
print("Hello world!")
sum([1，-6，23.6，7])
type(True)

自定义函数。除了内置函数，还可以自定义函数，格式如下，注意四个而空格缩进。

1
2
3
4
5
6
7
8
9
def calculate_sector_1():
    # 接下来是一些定义函数的代码
def calculate_sector(central_angle, radius):
    # 接下来是一些定义函数的代码
    sector_area = central angle /360*3.14 * radius
    print(f"此扇形面积为:{sector_area}")
    return sector_area

calculate_sector(160，30) # 调用函数:函数名加上括号，括号内为函数使用的参数

函数返回值 return。函数运行完成后，若没有写返回值，默认返回值为 None。

引入模块

import 语句

1
import 加上模块名      引入模块

需要使用模块的函数或变量的时候格式如下：
模块名.函数名
模块名.变量名

1
2
3
import statistics
print(statistics.median([19, -5, 36]))
print(statistics.mean([19, -5, 36]))

from…import… 语句

1
from 模块名 import 函数名,变量名         引入模块的某些函数或变量

from后面添加模块名，import后面添加函数名或变量名，需要引入多个的时候用逗号进行分隔。
此方法在使用时不需要再带上模块名。

1
2
3
from statistics import median, mean
print(median([19, -5, 36]))
print(mean([19, -5, 36]))

from…import * 语句

1
from 模块名 import *         引入模块的所有内容，此方法不建议使用。

from后面添加模块名，import后面加*号，将模块里面的所有内容进行引入，在使用时全都不需要在前面添加模块名。

优点：需要使用同一个模块的不同函数或变量可以直接使用，不需要再加模块名。

缺点：如果因引用多个模块，不同模块内可能包含相同名称的函数，运行时可能出现错误。

1
2
3
from statistics import *
print(median([19, -5, 36]))
print(mean([19, -5, 36]))

其他

  • 在PyCharm软件内查看Python模块函数代码方法，按住ctrl，再点击代码中的函数，即会显示源代码。
  • 除了引入官方的模块以外，还可以引入第三方模块，引入方法与引用官方模块一样，前提是引入之前需要提前安装好第三方的模块。
  • 第三方库搜索网站：PyPI · The Python Package Index。如果安装第三方库，在PyCharm的【终端】窗口输入 pip install 后面加上库的名字。安装完成后即可使用库的函数。

进阶函数

类

类的定义：class NameOfClass:

类的命名：Python常用类的命名方法为Pascal命名法，即首字母大写。

类的构造函数：主要作用是定义实例对象的属性。

  • 必须命名为 init 前后必须有两个下划线。括号内可以放任意数量的参数，但是第一个永远是被占用的，用于表示自身，约定俗称为self，它能把属性绑定在实列的对象上。

    1
    2
    3
    4
    5
    class CuteCat:
        def init (self):
            self.name = "Lambton"
    cat1 = CuteCat()
    print(cat1.name)

  • 从参数中获取值，在创建对象时，在括号内写入要传入的参数，__init__函数将会绑定传入的参数。

    1
    2
    3
    4
    5
    6
    class CuteCat:
      def _init_(self,cat_name,cat_age,cat_color):
          self.name = cat_name
          self.age = cat_age
          self.color = cat_color
    cat1 = CuteCat("Jojo",2,"橙色")

定义类的方法（函数）：

定义类的方法与创建普通函数差不多，有两点区别：

1、需要创建在class里面，前面需要有缩进，来表示属于该类的方法。
2、和 init 一样，第一个参数被占用，用于表示对象自身，约定俗成为 self 。

类的继承

子类可以继承父类的属性和方法。
在子类名称后的括号中写上父类的名称，此时父类的方法就会继承到子类中。

什么时候可以用继承？如果说A是B，那么就可以把A写成是B的子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 父类
class Mammal:
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes =2
def breathe(self):
    print(self.name +"在呼吸..")
def poop(self):
    print(self.name +"在吃饭...")

# 子类1 子类括号内填写父类名称
class Human(Mammal):
    def read(self):
        print(self.name +"在阅读..")
# 子类2
class Cat(Mammal):
    def scratch_sofa(self):
        print(self.name +"在抓沙发..")

调用函数和方法时，优先看所属的类是否有没有该方法函数，如果过有，则执行该类的方法，如果没有，会往上找父类的同名方法使用。

1
2
cat1 = Cat("Jojo","男")
cat1.poop()

如果子类程序中有__init__方法，则创建子类实例时优先调用子类的构造函数，导致实例只有子类的__init__中的属性参数，而父类的__init__属性参数不会被调用。此时在子类中用supper()方法，返回当前类的父类；

1
2
3
4
5
class Human(Mammal):
    def __init__(self,name,sex):
        self.has_tail = False
    def read(self):
        print(self.name +"在阅读..")

在子类的构造函数中写 supper()._init_()，则会调用父类的构造函数，子类将会继承父类的构造函数中的属性。

1
2
3
4
5
6
class Human(Mammal):
    def __init__(self,name,sex):
        super()._init_(name,sex)
        self.has_tail = False
    def read(self):
        print(self.name +"在阅读..")

文件路径

不同操作系统文件存储路径，Linux、macOS等操作系统所有文件存储在根目录下，根目录用斜杠(/)表示。

Windows操作系统每个磁盘分区都有根目录，用分区名加反斜杠(\)表示。

绝对路径：从根目录出发的路径。

对于Linux、macOS等系统，绝对路径以斜杠(/)开头，路径中每个目录间用斜杠分隔，最后以目标文件或目标目录结尾。
对于Windows系统，绝对路径以分区名加反斜杠(\)开头，路径中每个目录间用反斜杠分隔，最后以目标文件或目标目录结尾。

相对路径：从一个参考位置出发。表示从指定文件位置出发，其他文件处于什么路径。

用相对路径时，用点(.)表示参照物所在的目录，用点点(..)表示更上一层的父目录。如果继续往上走，就用点点(..)跟上斜杠或者反斜杠分隔，后面跟上点点(..)表示当前文件所属目录的父目录的父目录。如果是往更下层走，同样以斜杠或反斜杠来分隔路径中的目录。相对路径都是以点(.)或点点(..)开头。./(.\)可以省略，在同一路径下相互用相对路径找到彼此，可直接使用文件名。

文件操作

open() 方法，打开文件，括号内放文件路径，可以是相对路径也可以是绝对路径。

1
2
3
4
5
6
7
8
open("./data.txt")                  # 相对路径
open("/usr/demo/data.txt")       # 绝对路径
# open()方法的第二个参数表示模式，模式是一个字符串，常见的字符串有“r”，表示读取模式；“w”表示写入模式。
open("/usr/demo/data.txt", "r") 
# 注：第二个参数可以不写，不写时默认为读取模式 ”r”。读取模式下找不到文件会报FileNotFoundError错误，表示文件不存在。
# open()方法还有一个可选参数 encoding 表示编码方式。一般文件编码方式为 UTF-8。
f = open("./data.txt", "r", encoding="utf-8") 
# 如果open()方法执行成功，将会返回一个文件对象，后续可以对这个对象进行读取或写入操作。

读取文件方法一：read() 方法

一次性读取文件里面的所有内容，并以字符串的形式返回。一般操作的文件以文本为主。其他类似word文件内有字体颜色、字号区分的文件，很可能读取有误。

1
2
3
f = open("./data.txt", "r", encoding="utf-8") 
print(f.read()) # 会读全部的文件内容，并打印
print(f.read()) # 会读空字符串，并打印

运行read()方法后，再次调用时返回的结果为空，因为程序会记录文件读取到哪个位置，第一次运行read()时已经读到结尾，第二次运行时后面已经没有内容。

文件太大时不建议使用read()方法，因为读出来的内容会占用很大的内存。如果不需要一次性读取整个文件，可以在read()传一个数字，表示读多少个字节，下次调用read时会从上次结束位置继续往下读。

1
2
3
f = open("./data.txt", "r", encoding="utf-8") 
print(f.read(10)) # 会读第1-10个字节的文件内容
print(f.read(10)) # 会读第11-20个字节的文件

读取文件方法二：readline() 方法

只读取文件一行内容，下次调用时继续读取下一行，根据换行符来判断什么时候结束本行。并且换行符会被当成读到的内容的一部分。读取到结尾后，继续读取将会返回空字符串，表示后面已经无内容。

1
2
3
4
5
6
7
8
f = open("./data.txt", "r", encoding="utf-8") 
print(f.readline()) # 会读一行文件内容，并打印
print(f.readline()) # 会读一行文件内容，并打印
# 一般采用while循环判断，只要返回的不是空字符串就继续读取下一行，否则退出循环
line = f.readline() # 读第一行
while line !="": # 判断当前行是否为空
    print(line) # 不为空则打印当前行
    line = f.readline() # 读取下一行

读取文件方法三：readlines() 方法

返回全部文件内容组成的列表。读取文件内容，并将每行作为列表元素返回。

1
2
f = open("./data.txt", "r", encoding="utf-8") 
print(f.readlines())

一般和for循环结合使用。先调用readlines方法把每行读取出来，再逐行循环列表所有内容。

close() 方法，关闭文件

调用close方法后将会释放系统资源，每次调用文件完成后都应该关闭文件。

1
2
3
4
5
6
7
f = open("./data.txt")
print(f.read()) # 对文件的操作
f.close() # 关闭文件，释放资源

# 可以不用调用close方法，文件操作完成后会自动关闭文件。注意对文件操作的代码需要缩进，缩进的代码块执行完毕后会自动关闭文件。
with open("./data.txt") as f:
    print(f.read())  # 对文件的操作

write() 方法，写文件

写文件与读文件类似，都需要先打开文件，并且在操作完成后关闭文件。同样可以使用 with open() as f: 方式。

1
2
3
with open("./data.txt","w", encoding="utf-8") as f:
    f.write("Hello!\n")
    f.write("Yoooo" )

open的第二个参数传入w，即为写文件模式，写文件模式找不到文件，不会像读文件模式那样报错，而是自动创建传入文件名的那个文件。第三个参数为encoding编码格式。

注：使用w模式打开文件进行写入时，如果文件已存在，将会把原有文件内容全部清空。

若不想重写文件内容，而是增加文件内容，则open()的第二个参数需要传入附加模式”a”参数。文件名不存在时会直接创建文件。

with open("./data.txt","a", encoding="utf-8") as f:

无论是”w”模式，还是”a”模式，都不能读取文件原本的内容，如果在这两个模式下调用read()方法，程序会报错不支持读操作(UnsupporttedOperation)。

r+，同时支持读写文件

open()方法的第二个参数传入”r+”参数，就可以同时支持读写文件。

1
2
3
4
5
6
7
8
9
with open("./data.txt","r+", encoding="utf-8") as f:
    print(f.read())
    f.write("hello!")
# 会打印出
这是第一行
这是第二行
# 文件中会变成
这是第一行
这是第二行hello!

异常处理

1
2
3
4
5
6
7
8
9
10
IndentationError # 缩进错误
IndexError # 索引错误
SyntaxError # 语法错误
ValueError # 值错误
ImportError # 导入模块错误
KeyError # 键错误
ArithmeticError # 计算错误
ZeroDivisionError # 分母为零错误
AttributeError # 属性错误
ZeroDivisionError # 分母为零错

程序报错类型有很多。可以通过try/except语句捕捉异常，
try后加冒号，换行后在缩进的代码块里放入可能产生错误的代码，接下来在except后面跟上需要捕捉的错误名字以及冒号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try: # 有可能产生错误的代码
    user_weight = float(input("请输入您的体重(单位:kg)"))
    user_height = float(input("请输入您的身高(单位:m)"))
    user_BMI =user_weight /user_height ** 2
except ValueError: # 产生值错误时会运行
    print("输入不为合理数字，请重新运行程序，并输入正确的数字。")
except ZeroDivisionError: # 产生除零错误时会运行
    print("身高不能为零，请重新运行程序，并输入正确的数字。")
except: # 产生其它错误时会运行
    print("发生了未知错误，请重新运行程序。")
else: # 没有错误时会运行
    print("您的BMI值为:" + str(user_BMI))
finally: # 不论发生错误与否都会运行
    print("程序结束运行。")

try/except语句在捕捉错误时，依次从上往下运行，如果第一个except已经捕捉到错误，之后的except将不会执行，与if/elif语句类似，只有第一个符合条件的分支会运行。
else: 表示没有出现任何错误时执行的语句。
finally: 无论是否发生错误，都会执行的语句。

Python高阶和匿名函数

高阶函数

为了优雅直观的表示函数，可以将函数的各种计算方式独立成单独的函数。运行计算方式时直接调用传入的函数将计算结果显示出来。作为参数的函数是直接用函数名进行传入，表示函数其本身，后面不能带括号和参数，入过带括号，即表示调用此函数，从而传入的是函数的执行结果。高阶函数还可以同时调用多个函数。

匿名函数

匿名函数不需要写名字，即用即仍，可以把匿名函数当作没有名字且占用行数更少的函数。以lambda作为关键字。
可直接在高阶函数括号内写上关键字 lambda 再跟上变量名，再跟上冒号 : ，冒号后直接写需要返回的结果，无需写return。

1
def calculate_and_print(7, lambda num: num * 5, print_with_vertical_bar)

如果需要给匿名函数增加参数，直接用逗号分隔即可。

1
lambda num1, num2: num1 + num2

除了作为高阶函数的参数，匿名函数还可以定义好后直接被调用。调用方式和普通函数一样，都是括号，然后括号里面传入参数，唯一的区别是前面的匿名函数也是要被括住，表示这是一个整体。

1
(lambda num1, num2: num1 + num2)(2,3)

匿名函数也有局限性，冒号后没法有多个语句或表达式，只适用于比较简单的场景，对于多步骤的复杂逻辑或者设计循环递归等，它可能不灵活，没法用它写出来；即使写出来，可读性会很差。