入门

这里我就不再设置安装软件的步骤了，直接入门学习起来，需要安装步骤的，看我文章，如何安装python+pycharm，步骤很详细。
入门第一步：打印

print("hello world")  # 结果为 hello world

一、数据的相关操作

1、字符串格式化的语法：“%占位符” % 变量
例如，

print("%s" % s)
print("%s 我的%d，%f“ % (name,age,high))

2、字符串格式化—快速写法
语法：f”内容{变量}“的格式来快速的格式化
例如，

name = "小杰"
year = 1998
high = 178
print(f"我是{name}，我出生于{year}年，我今年的身高是{high}CM")。

输出结果：我是小杰，我出生于1998年，我今年的身高是178CM

这种做法的缺点就是不关心数据的类型跟精度，也不关心数据的宽度，只是把占位的数据给原样输出
input()函数会把所输入的东西都当做成字符串来存储，如果需要其他类型，请自行进行转换，使用int()，float()

3、输出不换行：

print("hello", end=' ')  # 这里有空格
print("world", end='')   # 这里也有空格

输出结果：hello world

4、for循环跟while循环之间的异同：

• while循环的循环条件是自定义的，自行控制循环条件。
• for循环是一种”轮询“机制，是对一批内容进行”逐个处理“，是无法定义循环条件的。

for 临时变量 in 待处理数据集：循环满足条件时执行的代码

语法中的“临时变量”，作用范围只限定在for循环的内部，但是如果在for循环外部进行访问临时变量的话，实际上是可以访问到的，在编程规范中，这种做法是不允许的、不建议这么做的。
”待处理数据集“，严格的来说，称之为是一种序列类型，它是指，内容可以一个个依次取出的一种类型，包括有1.字符串；2.列表；3.元组等。

5、for循环语句，本质上是遍历：序列类型。

• 语法1、range（num）
  获取一个从0开始，到num结束的数字序列（不包含num本身）
  如range(5)取得的数据是：[0,1,2,3,4]

• 语法2、range（num1，num2）
  获取一个从num1开始，到num2结束的数字序列（不包含num2本身）

• 语法3、range（num1，num2、step）
  获取一个从num1开始，到num2结束的数字序列（不包含num2本身），数字的步长为step（不写默认为1）
  如，range（5，10，2）取得的数据是：[5，7，9]

6、注释
注释分为单行注释跟多行注释，当然注释也不是必要的，注释是为了让代码更具有可读性，通过注释就可以看出代码的功能是什么。

• 单行注释
  单行注释我们用"#"来表示，如下

# 这个是单行注释，不会被执行
print("hello", end=' ')  # 这里有空格

• 多行注释

'''
print("hello", end=' ')
这个是多行注释，不会被执行
'''

需要注意的是，在注释里面的语句是不会被执行的，可认为编译器会直接跳过。

二、continue 和 break的区别（易混点）

1、continue关键字：中断本次循环，直接进入到下一次的循环，可用于for循环和while循环，效果是一样的。

for i in range(1,100):语句1continue语句2

在循环内，遇到 continue 就结束当次循环，进行下一次，所以语句2不会被执行。
应用场景：在某些情况中，需要结束当前循环，进行下次循环。

for i in range(1,100):语句1for j in range(1,100):语句2continue语句3语句4

以上代码：
语句1，语句2（会执行多次），语句4都会被执行，但是语句3会因为存在continue而不被执行，跳出本次循环，进行下次循环。

2、break关键字：直接结束循环，可用于for循环和while循环，效果是一样的。

for i in range(1,100):语句1break语句2

以上代码：
只能执行语句1（执行1次），整个循环都会结束。

for i in range(1,100):语句1for j in range(1,100):语句2break语句3语句4

以上代码：
语句1，语句2，语句4都会被执行，但是语句3会因为存在break而不被执行，且语句2只能 执行一次 ，跳出整个循环。

三、函数

定义：函数是组织好的，可重复使用的，用来实现特定功能的代码段。
使用函数的好处：（1）将功能封装在函数内，可供随时随地重复使用；（2）提高代码的复用性，减少重复代码，提高开发效率。
基本语法：

def 函数名():函数体

有基本的语法，当然还有高级的语法：

def 函数名(传入参数):函数体return 返回值

函数的调用： 函数名（参数）
函数的使用步骤： 先定义后使用
注意事项：
① 参数如不需要，可以省略
② 返回值如不需要，可以省略
③ 函数必须先定义后使用

函数的传入参数：
作用：在函数运行的时候，接受外部传入的数据
注意事项：

• 函数定义中的参数，称之为形式参数
• 函数调用中的参数，称之为实际参数
• 函数的参数数量是不限的，使用逗号分隔开
• 传入参数的时候，要和形式参数一一对应，逗号隔开

# 定义参数
def add(x,y):result = x + yprint(f"{x} + {y} 的结果为：{result}")# 传入参数
add(5,6)

定义函数的返回值的语法结构：

def add(x,y):result = a + breturn result# print("我完事了")  在return后面还有函数体不会被执行
r = add(5,6)
print(f"{r}")

变量的作用域

变量的作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类： 全局变量与局部变量
1、所谓局部变量是定义在函数体内部的变量，即只在函数体内部有效

# 定义局部变量a
def testA():num = 100print(num)
testA()  # 100
print(num)  # 报错：name 'num' is not defined

报错的原因是定义在testA函数内部的变量，在函数外部访问则立即报错/
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则立即销毁局部变量，之后不可使用。

2、所谓全局变量，指的是在函数体内、外都能生效的变量

# 定义全局变量a
num = 100
def testA():print(num)
testA()  # 100
print(num)  # 100

函数的嵌套使用。

# 定义全局变量a
num = 100
def testA():print(num)
def testB():num = 500print(num)  # 局部变量
testA()  # 100
testB()  # 500
print(num)  # 100而不是500

如果要输出500，则其在定义局部变量时，在变量前用 global关键字，代表将局部变量转变为全局变量

# 定义全局变量a
num = 100
def testA():print(num)
def testB():global numnum = 500print(num)  # 局部变量
testA()  # 100
testB()  # 500
print(num)  # 500

三、函数进阶

1、函数多个返回值

如果一个函数要有多个返回值，该如何书写代码？

按照返回值的顺序，写对应顺序的多个变量接受即可
变量之间用逗号隔开，支持不同类型的数据return

def test_func():return 1, "hello". Truex, y, z = test_func()
print(x)  # 结果1
print(y)  # 结果hello
print(y)  # 结果True

2、函数参数种类

使用方式上的不同，函数有4种常见参数使用方式
● 位置参数
调用函数时根据函数定义的参数位置来传递参数

def user_info(name, age, gender):print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
user_info('Tom', 20, '男')  # 按照顺序传入参数

● 关键字参数
函数调用时通过“键=值”的形式传递参数
作用：可以让函数更加的清晰、容易使用，同时消除了参数的顺序需求。

def user_info(name, age, gender):print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
# 关键字传参
user_info(name = "小明", age = 20, gender = "男")
# 也可以不按照固定顺序
user_info(age = 20, name = "小明", gender = "男")
#  ----------------------------------------------------
# 可以和位置参数混用，位置参数必须在前面，且匹配参数的顺序
user_info("小明", age = 20, gender = "男")

函数调用时，如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

● 缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用)
作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值，如果有传递参数，则覆盖默认参数。

def user_info(name, age, gender = '男'):print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
user_info('Tom', 20)  # 您的名字是Tom，年龄是20，性别是男
user_info('Rose', 18, '女')   # 您的名字是Rose，年龄是18，性别是女

函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值，并且这个缺省参数必须在最后，不能放在前面。

● 不定长参数
不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。
作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：①位置传递； ②关键字传递

3、匿名函数

在前面的函数学习中，我们一直使用的函数，都是接受数据作为参数传入：
● 数字
● 字符串
● 字典、列表、元组等

其实，我们学习的函数本身，也可以作为参数传入另一个函数内。

def test_func(compute):result = compute(1, 2)print(result)
def compute(x, y):return x + y
test_func(compute)   # 结果为3

这是一种计算逻辑的传递，而非是数据的传递。

lambda匿名函数
函数的定义中有：

• def关键字，可以定义 带有名称 的函数
• lambda关键字，可以定义匿名函数（无名称)

有名称的函数，可以基于名称 重复使用
无名称的匿名函数，只可 临时使用一次 。

匿名函数定义语法：

lambda 传入参数 : 函数体(一行代码)

● lambda是关键字，表示定义匿名函数
● 传入参数表示匿名函数的形式参数，如：x, y表示接收2个形式参数
● 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

来，我们结合代码一起来看一下，def关键字定义的函数跟lambda函数定义的函数之间的区别。

# 通过def关键字定义的函数，并传入数据
def test_func(compute):result = compute(1, 2)print(result)def compute(x, y):return x + y
test_func(compute)   # 结果为3# 通过lambda函数定义的匿名函数
def test_func(compute):result = compute(1, 2)print(result)test_func(lambda x, y : x + y)   # 结果为3

使用def关键字跟lambda关键字定义的函数功能是一致的，只是lambda关键字定义的函数是匿名的，无法二次使用。

组合数据类型

一、列表

1、list(列表)

思考：如果一个班级有100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？
答：No，我们使用列表就可以了，列表一次可以存储多个数据。

基本语法：

# 字面量
[元素1, 元素2, 元素3, 元素4,··.]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4,··.]
# 定义空列表
变量名称 = []
变量名称 = 1ist()

• 列表内的每一个数据，称之为元素
• 以 [ ] 作为标识
• 列表内每一个元素之间用‘，’逗号隔开

ls = [452, "BTF", [10, "CS"], 425]
print(ls)
[452, "BTF", [10, "CS"], 425]print(ls[2][-1][0])
'C'print(list((452, "BTF", [10, "CS"], 425))
[452, "BTF", [10, "CS"], 425]  # 这说明列表可以包括元组，集合，列表print(list("中国是一个伟大的国家"))
['中', '国', '是', '一', '个', '伟', '大', '的', '国', '家']  # 输出来的是一个列表print(list())
[]   # 输出的是一个空列表，list()函数可以将元组或字符串转化为列表。

2、下标索引

① 正向的下标索引：如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

② 反向的下标索引：当然也可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…)

③ 列表的嵌套：同样也可以支持下标索引

注意事项：下标索引的取值范围，超出范围无法取出元素，并且会报错

3、列表的查询功能（方法）

在Python中，如果将函数定义为class（类)的成员，那么函数会称之为：方法

# 函数
def add(x, y):return x + y
# 方法
class Student:def add(self, x, y):return x + y

方法和函数其实功能是一样，有传入参数，有返回值，只是方法的使用格式不同：
函数的使用：
num add(1,2)
方法的使用：

student = Student()
num = student.add(1, 2)

• 查找某元素的下标
  功能：查找指定元素在例表的下标，如果找不到，报错ValueError
  语法：列表.index(元素)
  index就是列表对象（变量）内置的方法（函数）

  mylist = ["python", "Java", "C"]
  index = mylist.index("python")
  print(f"python在列表中的下表索引值是：{index}")
  # python在列表中的下表索引值是：0
  

• 修改特定位置（索引)的元素值：
  语法：列表[下标] = 值
  可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改)

  mylist[0] = "HTML"
  

• 插入元素：
  语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

  mylist.insert(1, "SQL")
  

• 追加元素：
  语法：列表.ppend(元素)，将指定元素，追加到列表的尾部

  mylist = [1, 2, 3, 4]
  mylist = mylist.append(5)
  print(mylist)   # [1, 2, 3, 4, 5]
  

• 追加元素方式2：
  语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

  mylist = [1, 2, 3]
  mylist.extend([4, 5, 6])
  print(mylist)  # [1, 2, 3, 4, 5, 6]
  

• 删除元素（指定下标删除）
  语法1：del 列表[下标]

  mylist = ["python", "Java", "C"]
  del mylist[2]
  print(mylist)  # ["python", "Java"]
  

  语法2：列表.pop(下标)

  mylist = ["python", "Java", "C"]
  delete =  mylist.pop(2)
  print(mylist)  # ["python", "Java"]
  print(delete)  # C
  

• 删除某元素在列表中的第一个匹配项（指定元素删除）
  语法：列表.remove(元素)

  mylist = ["python", "Java", "C", "Java"]
  mylist.remove("Java")
  print(mylist)  # ["python", "C", "Java"]
  

注意事项：remove()方法是从前往后删除，找到第一个就删除掉，如果想把Java全部删除，则必须调用remove()方法两次哦

• 清空列表内容，
  语法：列表.clear()

  mylist.clear()
  print(mylist)  # [], 相当于是空列表了
  

• 统计某元素在列表内的数量（字符串、数字都可以统计）
  语法：列表count(元素)

  mylist = [1, 2, 3, 1, 1]
  print(mylist.count(1))  # 3
  

• 统计列表内，有多少元素
  语法：len(列表)
  可以得到一个int数字，表示列表内的元素数量

  mylist = [1, 2, 3, 4, 5]
  print(len(mylist)) # 5
  

总结：
1、列表的常见方法如下

2、列表的特点

• 可以容纳多个数据（上限为2**63-1、9223372036854775807个)
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修攻（增加、删除、插入元素等)

4、列表的循环遍历(迭代)

1、什么是遍历？
将容器内的元素依次取出，并处理，称之为遍、迭代历操作。
2、如何遍历列表的元素呢？
可以使用前面学过的while循环
3、如何在循环中取出列表的元素呢？
使用列表[下标]的方式取出
4、循环条件如何控制？
定义一个变量表示下标，从0开始；循环条件为下标值<列表的元素数量

• while循环
  语法结构：

index = 0
while index < len(列表):元素 = 列表[index]对元素进行处理index += 1

举个栗子：

mylist = ["python", "C", "Java"]
index = 0
while index < len(mylist):element = mylist[index]print(f"列表中的元素有：{element}")index += 1

• for循环
  语法结构：

for 临时变量 in 数据容器:对临时变量进行处理

举个栗子：

mylist = [1, 2, 3, 4, 5]
for element in mylist:print(f"列表中的元素有：{element}")

while循环和for循环，都是循环语句，但细节不同：

• 在循环控制上：

  • whle循环可以自定循环条件，并自行控制
  • f和r循环不可以自定循环条件，只可以一个个从容器内取出数据

• 在无限循环上：

  • whe循环可以通过条件控制做到无限循环
  • fo循环理论上不可以，因为被遍历的容器容量不是无限的

• 在使用场景上：

  • while循环适用于任何想要循环的场景
  • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

二、元组(tuple)

1、元组定义

思考：列表是可以修改的。
如果想要传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：元组一旦定义完成，就不可修改，所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。
元组定义：定义元组使用小括号，且使用 逗号 隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量
(元素，元素，……，元素)
# 定义元组变量
变量名称 =（元素，元素，……，元素）
# 定义空元组
变量名称 = ()  # 方式1
变量名称 = tup1e()   # 方式2

元组的相关操作：

• 不可以修改元组的内容，否则会直接报错

# 尝试修改元组的内容
t1 = (1, 2, 3)
t1[0] = 5  # 报错信息：TypeError:'tuple' object does not support item assignment

• 可以修改元组内的list的内容（修改元素、增加、删除、反转等操作）

# 尝试修改元组的内容
t1 = (1, 2, ['python', 'Java', 'C'])
t1[2][1] = 'best'
print(t1)  # 结果：(1, 2, ['python', 'best', 'C'])

2、元组的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装)，里面的数据类型可以嵌套，不相同
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等)
• 支持for循环，跟列表的操作类似

多数特性和list一致，不同点在于不可修改的特性。

三、字符串

1、字符串的定义

字符串是字符的容器，一个字符串可以存放任意数量的字符。

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

# 通过下标获取特定位置字符
name = "i love pyhton"
print(name[0])  # 结果为：i
print(name[-1])  # 结果为：n

同元组一样，字符串是一个 无法修改 的数据容器。

2、字符串的替换

语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串哦

name = "i love pyhton"
new_name = name.replace("i", "you")
print(f"将字符串{name}，进行复制替换成：{new_name}")  # 将字符串i love pyhton，进行复制替换成：you love pyhton

3、字符串的分割

语法：字符串.splt(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存人列表对象中
注意：字符串本身不变，而是得到了一个列表对象

my_str = "i love python"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切割后得到：{my_str_list}，类型是{type(my_str_list )}")
# 将字符串i love python进行split切割后得到：['i', 'love', 'python']，类型是<class 'list'>

4、字符串的常用操作

• 字符串的规整操作（去前后空格)
  语法：字符串.strip()

my_str = "  i and you  "
print(my_str.strip())  # 结果："i and you"

• 字符串的规整操作（去前后指定字符串）
  语法：字符串.strip(字符串)

my_str = "12i and you21"
print(my_str.strip("12"))  # 结果："i and you"

注意，传入的是“12”其实就是：”1”和”2”都会移除，是按照单个字符进行移除。

• 统计字符串中某个字符出现的次数
  语法：字符串.count(字符串)
• 统计字符串的长度
  语法：len(字符串)

总结：
1、 常见操作

2、作为数据容器，字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等)
• 支持for循环

四、序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串均可以可以视为序列。

1、 序列的操作

• 切片操作
  序列支持切片，即列表、元组字符串均支持切片的操作
  切片：就是从序列中，取出一个子序列
  语法：序列[起始下标 : 结束下标 : 步长]
  表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
  • 起始下标表示从何处开始，可以留空，留空视作从头开始
  • 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
  • 步长表示，依次取元素的间隔
    • 步长1表示，一个个取元素
    • 步长2表示，每次跳过1个元素取
    • 步长N表示，每次跳过N-1个元素取
    • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意：此操作不会影响序列本身，而是会得到一个新的序列（因为字符串，元组都是不可修改的序列）

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]  # 步长默认是1，所以可以省略不写
print(f"结果为1：{result1}")   # 结果为1：[1, 2, 3]# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]  # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果为2：{result2}")   # 结果为2：(0, 1, 2, 3, 4, 5, 6)# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果为3：{result3}")   # 结果为3：0246# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]    # 等同于将序列反转了
print(f"结果为4：{result4}")   # 结果为4：76543210# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_str[3:1:-1]
print(f"结果为5：{result5}")   # 结果为5：[3, 2]# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]  # 等同于将序列反转了，步长为2
print(f"结果为6：{result6}")   # 结果为6：(6，4, 2, 0)

五、集合(set)

我们目前接触到了列表、元组、字符串三个数据容器了，基本满足大多数的使用场景。
为何又需要学习新的集合类型呢？
通过特性来分析：
列表可修改、支持重复元素且有序 ；元组、字符串不可修改、支持重复元素且有序
有没有看出一些局限？

局限就在于：它们都支持重复元素。
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。
而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

1、定义

基本语法：

# 定义集合字面量
{元素, 元素, 元素, ……, 元素}
# 定义集合变量
变量名称 = {元素, 元素, 元素, ……, 元素}
# 定义空集合
变量名称 = set()  # 注意与定义空元组区别

和列表、元组、字符串等定义基本相同：

• 列表使用：[]
• 元组使用：()
• 字符串使用：“”
• 集合使用：{}

my_set = {"python", "Java", "C"}
my_set_empty = set()  # 定义空集合
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")  # my_set的内容是：{"python", "Java", "C"}，类型是：<class 'set'>
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")  # my_set的内容是：set()，类型是：<class 'set'>

2、集合的常用操作—修改

首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

• 添加新元素
  语法：集合.ddd(元素)，
  功能：将指定元素，添加到集合内
  结果：集合本身被修改，添加了新元素

my_set = {"Hello","world"}
my_set.add("itpython")
my_set.add("Hello")   # 去重的，不会添加进去
print(f"my_set添加元素后的结果是：{my_set}")   # my_set添加元素后的结果是：{'Hello','world','itpython'}

• 移除元素
  语法：集合.remove(元素)，
  功能：将指定元素，从集合内移除
  结果：集合本身被修改，移除了元素

my_set = {'Hello','world','itpython'}
my_set.remove("itpython")
print(f"my_set移除itpython元素后的结果是：{my_set}")   # my_set添加元素后的结果是：{'Hello','world'}

• 从集合中随机取出元素
  语法：集合.pop()，
  功能：从集合中随机取出一个元素
  结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

my_set = {'Hello','world','itpython'}
element = my_set.pop()  # 随机取出集合中的一个元素
print(my_set)   # 结果是：{'Hello','world'}
print(element)   # 结果是：{'itpython'}

• 清空集合
  语法：集合.clear()，
  功能：清空集合
  结果：集合本身被清空

my_set = {'Hello','world','itpython'}
my_set.clear()   # 清空集合
print(my_set)   # 结果为：set()

下面，重点来了，别的序列都没接触过的东西

• 取出2个集合的差集
  语法：集合1.difference(集合2)，
  功能：取出集合1和集合2的 差集（集合1有而集合2没有的）
  结果：得到一个新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set3)   # 结果为：{2, 3}  得到一个新的集合
print(set1)   # 结果为：{1, 2, 3}  不发生改变
print(set2)   # 结果为：{1, 5, 6}   不发生改变

• 消除2个集合的差集
  语法：集合1.difference_update(集合2)
  功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
  结果：集合1被修改，集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)   # 结果为：{2, 3}  删除了与集合2相同的元素1
print(set2)   # 结果为：{1, 5, 6}   不发生改变

• 2个集合合并
  语法：集合1.union(集合2)
  功能：将集合1和集合2组合成新集合
  结果：得到新集合，集合1和集合2不变，并且实现去重

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)   # 结果为：{1, 2, 3, 5, 6}  得到一个新的集合
print(set1)   # 结果为：{1, 2, 3}  不发生改变
print(set2)   # 结果为：{1, 5, 6}   不发生改变

• 统计集合元素的数量len()

set1 = {1, 2, 3, 1, 2, 3, 4, 5}
num = len(set1)
print(num)   # 结果为：5，重复的不会计数多次

• 集合的遍历
  因为集合不支持下标索引，所有不能使用while循环，只能使用for循环进行遍历操作

set1 = {1, 2, 3, 4, 5}
for element in set1:print(f"集合中的元素有：{element}")

总结：
1、常见操作

2、集合的特点：
经过上述对集合的学习，可以总结出集合有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等)
• 支持for循环

六、字典

为什么要使用字典呢？
老师有一份名单，记录了学生的姓名和考试总成绩。

现需要将其通过Python记录至程序当中，并可以通过学生姓名检索学生的成绩。

那么这时，使用字典就最为合适了。

1、定义

字典的定义，同样使用{}，不过存储的元素是一个个的键值对 加粗样式，如下语法：

# 定义字典字面量
{key:value, key:value, ......key:value}
# 定义字典变量
my_dict = {key:value,key:value,......key:value}
# 定义空字典
my_dict = {}   # 空字典定义方式1
my_dict = dict()  # 空字典定义方式2

很多小伙伴可能会想到了集合中定义空集合的语法：set()，是不是发现这里使用{}就用了定义字典里，所以定义集合就只能用set()。

注意事项：字典的定义中，key是不允许重复，如果重复了的话，会使用后面的一个，利用后面定义的覆盖掉前面所定义的值。

my_dict1 = {"张三" = 55, "张三" = 65, "刘四" = 95, "李飞" = 99, "王正" = 98 }
print(stu_scores["张三"])  # 结果为：65，后面的覆盖掉前面的数值

2、字典数据的获取

字典同集合一样，不可以使用下标索引
但是字典可以通过key值来取得对应的Value

stu_scores = {"张三" = 65, "刘四" = 95, "李飞" = 99, "王正" = 98 }
print(stu_scores["张三"])  # 结果为：65
score = stu_scores["李飞"]
print(f"李飞的考试分数是：{score}")  # 结果为：李飞的考试分数是：95

3、字典的嵌套

字典的Key和Value可以是任意数据类型 (Key不可为字典)，那么，就表明，字典是可以嵌套的。
需求如下：记录学生各科的考试信息

stu_score_dict = {"王力鸿":{"语文":77,"数学":66,"英语":33}, "周杰轮":{"语文":88,"数学":86,"英语":55},"林俊节":{"语文":99,"数学":96,"英语":66}
}

类似于json文件。
从嵌套字典中获取信息，通过键来获取：

# 查看周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")    # 周杰轮的语文分数是：88

注意事项：

• 键值对的Key与Value可以是任意类型（Key不可为字典）
• 字典中Key不允许重复，重复添加等同于覆盖原有的数据
• 字典不支持下标索引，而是通过Key检索Value

4、 字典的常用操作

• 新增元素
  语法：字典[Key] = Value，结果：字典被修改，新增了元素

stu_score = {"王力鸿"：77，"周杰轮"：88，"林俊节"：99
}
# 新增，张学油的考试成绩
stu_score['张学油'] = 66
print(stu_score)   # 结果：{'王力鸿'：77，'周杰轮'：88，林俊节'：99，张学油'：66}

• 更新元素
  语法：字典[Key] = Value，结果：字典被修改，元素被更新
  注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

stu_score = {"王力鸿"：77，"周杰轮"：88，"林俊节"：99
}
# 修改周杰轮的考试成绩
stu_score['周杰轮'] = 66
print(stu_score)   # 结果：{'王力鸿'：77，'周杰轮'：66，林俊节'：99}

• 删除元素
  语法：字典.pop(Key)，
  结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

stu_score = {"王力鸿"：77，"周杰轮"：88，"林俊节"：99
}
# 删除元素
score = stu_score.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}，周杰轮的考试分数是：{score}")
# 字典中被移除了一个元素，结果：{'王力鸿'：77，林俊节'：99}，周杰轮的考试分数是：33
- 清空元素
语法：字典.clear()
结果：字典被修改，元素被清空
# 清空元素，clear
stu_score.clear()
print(f"字典被清空了，内容是：{my_dict}")   # 字典被清空了，内容是：{}

• 获取全部的key
  语法：字典.keys()，
  结果：得到字典中的全部Key

stu_score ={"王力鸿"：77，"周杰轮"：88，"林俊节"：99}
keys = stu_score.keys()
print(f"字典的全部keys是：{keys}")  # 字典的全部keys是：dict_keys(['王力鸿'，'周杰轮'，'林俊节'])# 字典的遍历方法1
for key in keys:print(f"字典的key是：{key}")print(f"字典的Value是：{stu_score[key]}")# 字典的遍历方法2
for key in stu_score:print(f"字典的key是：{key}")print(f"字典的Value是：{stu_score[key]}")# 统计字典内的元素数量，len()函数
num = len(stu_score)
print(f"字典中的元素数量有：{num}个")  # 字典中的元素数量有：3个

总结：
1、字典的常用操作

2、字典的特点
经过上述对字典的学习，可以总结出字典有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是Key:Value键值对
• 可以通过Key获取到Value,Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持for循环，不支持while循环(因为不支持下标索引)

七、总结

1、数据容器可以从以下视角进行简单的分类：

• 是否支持下标索引
  • 支持：列表、元组、字符串 一 序列类型
  • 不支持：集合、字典 一 非序列类型
• 是否支持重复元素：
  • 支持：列表、元组、字符串 一 序列类型
  • 不支持：集合、字典 一 非序列类型
• 是否可以修改
  • 支持：列表、集合、字典
  • 不支持：元组、字符串
    

二、 区别之处：

基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

三、相似点：

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。
首先，在遍历上：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引)

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

特殊情况：
字典转换成字符串才保留数值，而其余转换都是只能保留key，去除值。
转为字符串显示的是“容器”，但是解释器会出去“引号”，切记。
不能统统转换为字典，因为字典是键值对，其余容器不具备。

四、通用排序功能

sorted(容器, [reverse=True])
将给定 容器 进行排序，默认是按照升序排序，相当于(reverse = Falese)，设置为 reverse = True 的话，就是按照降序排序

python的文件操作

一、文件编码的概念

1.什么是编码？
编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。
编码有许多中，我们最常用的是UTF-8编码。
2.为什么需要使用编码？
计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。
同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。

二、文件读取操作

open() 打开函数
在Python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下

open(name, mode, encoding)

name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode：设置打开文件的模式（访问模式）：只读(read)、写入(write)、追加(append)等。
encoding：编码格式（推荐使用UTF-8)
示例代码：

f = open('python.txt', 'r', encoding="UTF-8")
#  encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定

注意事项
注意：此时的 ‘f’ 是 ‘open’ 函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象、属性或对象，方法对其进行访问，后续在面向对象模块中会给大家进行详细的介绍。

我们先来看 “r” 模式
● read()方法：

文件对象.read(num)

num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
例子

f = open('python.txt', 'r', encoding="UTF-8")
print(f"读取10个字节的结果是：{f.read(10)}")  # 返回的是文本文件中前十个字节
print(f"read方法读取全部内容的结果是：{f.read()}")   # 返回前十个字节之后的剩余内容

请看上面代码read()方法输出的结果是什么呢，思考代码输出的是什么

f = open('python.txt', 'r', encoding="UTF-8")
print(f"read方法读取全部内容的结果是：{f.read()}")  # 读取全部内容

这里小细节，大家切记。

● readlines)方法：
readlines可以按照 行 的方式把整个文件中的内容进行一次性读取，并且返回的是一列表，其中每一行的数据为一个元素。

f = open("python.txt", 'r', encoding="UTF-8")
print(f"readlines方法读取一行内容的结果是：{f.readlines()}")  # 输出的是一个列表，并且是读取的全部行，回车符号用\n表示。['python\n', 'Java\n', 'C']

● readline()方法：
一次读取一行内容。

f = open("python.txt", "r", encoding="UTF-8")
content1 = f.readline()
print(f"第一行：{content1}")
content2 = f.readline()
print(f"第二行：{content2}")
# 关闭文件
f.close()

for循环读取文件行

f = open("python.txt", "r", encoding="UTF-8")
for line in f:
print(line)
# 每一个line是临时变量，就记录了文件的一行数据

close() 关闭文件对象，否则文件一直呗占用，不能对文件进行重命名，删除等操作

f = open("python.txt","r", encoding="UTF-8")
f.close()
# 最后通过close，关闭文件对象，也就是关闭对文件的占用
# 如果不调用close，同时程序没有停止运行，那么这个文件将一直被Python程序占用。

使用with open，最后直接关闭文件，防止遗忘掉close()

with open("python.txt", "r", encoding="UTF-8") as f:
f.readlines()
# 通过在with open的语句块中对文件进行操作
# 可以在操作完成后自动关闭close文件，避免遗忘掉close方法

三、文件写入操作

# 1.打开文件
f = open("python.txt", "w", encoding = "utf-8")
# 2.文件写入
f.write('hello world')
# 3.内容刷新
f.flush()

注意：

• 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
• 当调用flush的时候，内容会真正写入文件
• 这样做是避免频繁的操作硬盘，导致效率下降（赞一堆，一次性写磁盘）
  

import time  # 导入time包
f = open("python.txt", "w", encoding = "utf-8")   # w操作，文件：无则创建，有则清空
# 2.文件写入
f.write('hello world')  # 将内容写入内存
# 3.内容刷新
f.flush()    # 将内存中的数据写入到硬盘中
time.sleep(500000)   # 让程序进入到睡眠模式，不会暂停程序

上述是使用 “f.flush()” 来写入数据，更简单的方法是我们直接使用f.close()来关闭文件即可，因为里面内置了flush的功能，所以不需要flush了。

总结：
1.写入文件使用open函数的 “w” 模式进行写入
2.写入的方法有：

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项：

• W模式，文件不存在，会创建新文件
• W模式，文件存在，会清空原有内容
• close(0方法，带有flush()方法的功能，相当于自动保存的功能

四、文件追加操作

# 1.打开文件
f = open("python.txt", "a", encoding = "utf-8")  # 没有python.txt这个文件，会自动创建
# 2.文件写入
f.write('hello world')
# 3.内容刷新
f.flush()
# 4.关闭操作
f.close()  # 文件内容：hello world

a操作跟w操作类似，没有文件，就创建文件，但是a操作是对内容追加，原有内容不会改变。

# 1.打开文件
f = open("python.txt", "a", encoding = "utf-8")  # python.txt已存在
# 2.文件写入
f.write('i love python')
# 3.关闭操作
f.close()   # 文件内容：hello worldi love python

总结：
1.追加写入文件使用open函数的"a"模式进行写入
2.追加写入的方法有（和w模式一致）：

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项：

• a模式，文件不存在，会创建新文件
• a模式，文件存在，会在原有内容后面 继续写入
• 可以使用”\n”来写出换行符

异常

一、概念

什么是异常？
当检测到一个错误时，Pythonf解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”，也就是我们常说的BUG

为什么需要捕获异常
当我们的程序遇到了BUG,那么接下来有两种情况：
① 整个程序因为一个BUG停止运行
② 对BUG进行提醒，整个程序继续运行
显然在之前的学习中，我们所有的程序遇到邮UG就会出现①的这种情况，也就是整个程序直接奔溃，但是在真实工作中，我们肯定不能因为一个小的BUG就让整个程序全部奔溃，也就是我们希望的是达到②的这种情况，那这里我们就需要使用到捕获异常。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

二、异常的捕获

基本语法：

try:可能发生错误的代码
except:如果出现异常执行的代码

例如：
需求：尝试以r模式打开文件，如果文件不存在，则以w方式打开。

try:f = open("linux.txt", "r")
except:f = open("linux.txt", "w")

捕获异常的语法相当于是Excel中iferror方法一样，错了程序该做什么。

捕获异常的语法：

try:可能要发生异常的语句
except:[异常  as  别名：]
[else:]未出现异常对应执行的语句
[finally:]不管出不出现异常都会做的事情

捕获指定的异常

# 捕获指定的异常
try:print(name)
except NameError as a:    # as后面那个相当于起别名，a，b，c，d...print("出现了变量未定义的异常")print(e)  # name 'name' is not defined

捕获多个异常
当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写。

# 捕获多个异常
try:print(1/0)
except (NameError, ZeroDivisionError):print('ZeroDivision错误...')

捕获全部异常

# 捕获全部异常
try:print(1/0)
except Exception as e:print("出现异常了")

异常else
else表示的是如果没有异常要执行的代码。

try:print(1)
except Exception as e:print(e)
else:print("我是else, 是没有异常的时候执行的代码")

异常的finally
finally表示的是无论是否异常都要执行的代码，例如关闭文件。

try:f = open('test.txt','r')
except Exception as e:f = open('test.txt','w')
else:print("没有异常，真开心")
finally:f.close()   # 不管有没有异常都要执行的语句

需要注意的是，异常是具有传递性的，跟函数的嵌套是一样，注意一层一层的逻辑关系。

模块

1、模块的导入

什么是模块？
Python 模块(Module)，是一个Python文件，以·.py 结
模块能定义函数，类和变量，模块里也能包含可执行的代码
模块的作用：python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块
我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能。
大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）

模块在使用前需要先导入，语法如下：

[from 模块名] import [模块 | 类 | 变量 | 函数 | * ] [as 别名]

常用的组合形式如：

• import 模块名
• from 模块名 import 类、变量、方法等
• from 模块名 import *
• import 模块名 as 别名
• from 模块名 import 功能名 as 别名

基本语法：

import 模块名
import 模块名1, 模块名2模块名.功能名()   # 使用功能名的功能

案例：导入time模块

# 导入时间模块
import time
print("开始")
# 让程序睡眠1秒（阻塞）
time.sleep(1)  # 通过.  就可以使用模块内部的全部功能（类、函数、变量等）
print("结束")

from 模块名 import 功能名
基本语法：

from 模块名 import 功能名功能名()

案例：导入time模块中的sleep方法

# 导入时间模块中的sleep方法
from time import sleep
print("开始")
# 让程序睡眠1秒（阻塞）
sleep(1)
print("结束")

from 模块名 import *
基本语法：

from 模块名 import *功能名()

案例：导入time模块中所有的方法

# 导入时间模块中所有的方法
from time import *
print("开始")
# 让程序睡眠1秒（阻塞）
sleep(1)
print("结束")

as 定义别名
基本语法：

# 模块定义别名
import 模块名 as 别名
# 功能定义别名
from 模块名 import 功能 as 别名

案例：

# 模块别名
import time as tt
tt.sleep(2)
print('hello')
# 功能别名
from time import sleep as sl
sl(2)
print('hello'）

二、自定义模块

制作自定义模块
Pythor中己经帮我们实现了很多的模块，不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现，就是自己制作一个模块
案例：新建一个Python文件，命名为my_modulel.py，并定义test函数

注意事项：如果调用了来自不同模块的功能代码，执行谁呢？
例如：

# 模块1代码
def my_test(a, b):print(a + b)
# 模块2代码
def my_test(a, b):print(a - b)
# 导入模块和调用功能代码
from my_modulel import my_test
from my_module2 import my_test
# my_test函数是模块2中的函数
my_test(1,1)  # 结果为0

你会发现，模块的使用是有先后顺序的，后面模块的功能代码会覆盖掉之前。

# 模块代码:my_module1
def test(a, b):print(a + b)
test(1, 2)  # 一执行结果为3# 调用my_module1模块
from my_module1 import test  # 导入就给我执行了模块中的test了，我不想执行那么我就可以在my_module1中使用一个main

解决办法如下(” main“的使用)：

# 模块代码:my_module1
def test(a, b):print(a + b)
if __main__ == "__main__":test(1, 2)   # 这样操作的话，就可以在my_module1模块中进行操作，但是引用模块的文件不会有结果。

 

_ all _
如果一个模块文件中有" _ all _"变量，当使用‘from xxx import ’来导入时，只能导入列表中的元素。

注意：" _ all _"变量是作用到上，而不是作用到函数、类上
例如：

from my_module1 import test_b  # 就可以使用test的功能了

总结：
1.如何自定义模块并导入？
在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用。

2._main_变量的功能是？
if main == "main"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入。

3.注意事项

• 不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
• __all__变量可以控制 import * 的时候 哪些功能 可以被导入

Python初级学习教程—从入门开始学习（函数、组合数据类型、文件操作、异常、模块）相关推荐

1. linux学习教程，入门手册(详细且全面)，linux课程超5万字总结[记得收藏]

      linux的基础学习分享到这篇就结束了,本篇文章做最后的总结,也是对前面发布的linux学习的补足,并增加了linux的文件操作函数和目录操作函数部分,学海无涯,学无止境,linux的基础学习截 ...

2. Python编程从入门到实践 第十章：文件和异常 练习答案记录

   Python编程从入门到实践 第十章:文件和异常 练习答案记录 练习题导航 Python编程从入门到实践 第十章:文件和异常 练习答案记录 10.1 从文件中读取数据 10.1.1 读取整个文件 10 ...

3. python中系列的含义_python中四种组合数据类型的含义、声明、增删改查，遍历

   一.列表 列表:list 可以存储多个有顺序的可以重复的数据的类型 其他语言:数据:python中~提供的是列表[不说数组] 列表:操作数据:增加.删除.修改.查询 [CRUD] append/ins ...

4. python的文件操作、模块操作、os模块、time、datatime模块以及模块的制作

   Day12新手小白学python 第十二节 python的文件操作.模块操作.os模块.time.datatime模块以及模块的制作 目录 Day12新手小白学python 前言 一.文件打开关闭 二 ...

5. Java学习路线，java学习教程（入门到精通）

   你好,欢迎来到编程领域:阅读"Java入门",打包好了Java学习包,以及良好的阅读体验. 关于 Java 语言 由于 JVM 的支持,使得 Java 成为一种跨平台的编程语言,一 ...

6. 长短时记忆神经网络python代码_零基础入门深度学习(6) - 长短时记忆网络(LSTM)

   无论即将到来的是大数据时代还是人工智能时代,亦或是传统行业使用人工智能在云上处理大数据的时代,作为一个有理想有追求的程序员,不懂深度学习(Deep Learning)这个超热的技术,会不会感觉马上就o ...

7. Python碎片化学习教程 @19. 在指定路径下创建.txt文件，并写入内容

   代码功能:在指定路径下创建.txt文件,并写入内容 代码如下: file = open("1.txt", "w", encoding="utf8&qu ...

8. [资源]推荐一些Python书籍和教程，入门和进阶的都有！

   前几天后台有读者留言说希望推荐一些入门的书籍,所以这几天都在整理一些我入门时候学习过的书籍教程,或者是口碑还不错的书籍! 入门和进阶书籍教程 入门和进阶方面的书籍教程,这里推荐两本书和一个教程. 1. ...

9. python程序设计案例教程 张思民_《Python程序设计案例教程——从入门到机器学习（微课版）》.doc...

   1 - 1 - 作者:张思民 定价:49元 ISBN:9787302510147 <Python应用程序设计>课程教学大纲 一.课程基本信息 中文名称:Python应用程序设计 英文名称: ...

最新文章

1. python tkinter窗口弹出置顶的方法
2. 关于学习Python的一点学习总结（24-＞列表推导）
3. 郑州学python_郑州Python基础知识点学习之内置类型
4. anjularjs 路由
5. 做“是非题”的正确姿势
6. C# XML添加删除/SelectNodes/xpath
7. nginx请求转发被拒绝_nginx反向代理（请求转发-URL匹配规则）
8. （19）Xilinx PCIE中断理论（学无止境）
9. navicat连接PostgreSQL报：column “rolcatupdate” does not exist ...错误的解决办法
10. mybatis 之 parameterType=list1
11. Oracle_视图_索引_plsql_游标_存储过程_存储函数_触发器
12. 企业信息化规划的重要性
13. FEMTransfer软件实现Patran/Nastran/Abaqus/Ansys/Sesam(Genie)/Workbench/Femap/盈建科/PKPM仿真分析软件的有限元模型相互转换导入
14. 转载《2020年校招面经心得》
15. 建议收藏|一文带你读懂 Prisma 的使用
16. 常用图形渲染API简介
17. 反相器，传输门，电平移位
18. python和大数据有什么关系
19. 支付平台--清结算流程详解及对账详解
20. 做实验的顺序【重要】

热门文章

1. java蓝桥杯数字黑洞_【蓝桥杯】数字黑洞（5位黑洞数）
2. 拼图java 源代码,Java语言实现拼图游戏源代码
3. 504服务器无响应,什么是504网关超时错误（以及如何解决）？ | MOS86
4. 《R语言数据挖掘》读书笔记：五、聚类分析
5. python计算器程序_python练习 计算器模拟程序
6. 修改php-fpm监听端口,如何修改php fpm监听端口
7. 以史为镜，认知计算机操作系统
8. promise，回调地狱
9. 夏季哪些蔬菜不适合生吃凉拌，食用会发生危险
10. Discuz x2 数据字典