Python基础知识

写在前面

遇到Pycharm2023.2左右版本出现项目一直卡在正在关闭项目的问题，参考一下两篇解决办法

👉解决办法1

👉解决办法2

基础语法

字面量

注释

1
2
3
4
5
6
7
8
 # 单行注释
print("单行注释")

"""
    多行注释以三引号
"""

print("wq")

变量

变量：在程序运行时，能存储计算结果或能表示值的抽象概念
变量名= 变量值

1
2
3
4
5
6
7
8
9
10
# 定义一个变量记录值
money = 50

# 打印值

print(money)

money = money-10

print(money)

数据类型

常见三种类型：String、int （Integer）、Float

type(被查看的数据类型)

1
2
3
4
5
6
7
8
print(type("qqqq"))
print(type(123))
print(type(12.22))

ns= "123"

print(type(ns))

数据类型转换

int(x) 将x转换为整数
float(x) 将x转换为浮点数
str(x) 将x转换为字符串

1
2
3
4
5
6
7
8
9
# 将数字转换为字符串
num_str = str(11)
print(type(num_str),num_str)

# 将字符串转换为数字

str_num = int("11")
print(type(str_num))

标识符

变量名：由字母、数字、下划线组成，且必须以字母或下划线开头，且不能是关键字

运算符

常见的赋值运算符有以下几种：

=：这是最基本的赋值运算符，用于将右侧的值赋给左侧的变量。

x = 10
+=：这是加法赋值运算符，它将左侧变量与右侧值相加，然后将结果赋给左侧变量。

x += 5 # 等同于 x = x + 5
-=：这是减法赋值运算符，它将左侧变量减去右侧值，然后将结果赋给左侧变量。

x -= 5 # 等同于 x = x - 5
*=：这是乘法赋值运算符，它将左侧变量与右侧值相乘，然后将结果赋给左侧变量。

x *= 5 # 等同于 x = x * 5
/=：这是除法赋值运算符，它将左侧变量除以右侧值，然后将结果赋给左侧变量。

x /= 5 # 等同于 x = x / 5
%=：这是取模（求余数）赋值运算符，它将左侧变量对右侧值取模，然后将结果赋给左侧变量。

x %= 5 # 等同于 x = x % 5
**=：这是幂赋值运算符，它将左侧变量与右侧值进行幂运算（左侧变量为底数，右侧值为指数），然后将结果赋给左侧变量。

x **= 2 # 等同于 x = x ** 2
//=：这是整除赋值运算符，它将左侧变量对右侧值进行整除（丢弃余数），然后将结果赋给左侧变量。

x //= 5 # 等同于 x = x // 5

字符串拓展

字符串的三种定义方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 单引号进行包围
name = 'zzh'

# 双引号进行包围

name1 = "zzh"

# 三引号进行包围

name2 = """zzh"""

# 在字符串内包含双引号

name3 = '"zzh"'

# 在字符串内包含单引号
name4 = "'zzh'"

# 使用转义字符\解除双引号的效用
name5 = "\"zzh"

字符串的拼接

1
2
3
4
5
6
7
8
9
10
11
12
# 字符串字面量之间的拼接
print("sssss"+"s1111")

# 字符串字面量和字符串的拼接

name = "zzh"
address = "sh sssa aa"
tel = 123455

print(name + address)
# 报错
print(name + address + tel)

字符串的格式化

%s

  • % 表示占位
  • s 表示将变量变成字符串放置在占位符中
    注意：
    多个变量占位变量要用括号括起来并按照占位的顺序填入
1
2
3
4
5
6
7
8
9
10
11
12

# 通过占位的形式，完成拼接
name = "zzh"
message = "%s love xue xi" % name
print(message)

# 通过占位的形式，完成数字和字符串的拼接

class_num = 57
avg_salary = 178123
message = "Python大数据学科，北京%s期，毕业平均工资: %s" % (class_num, avg_salary)
print(message)

格式符号 和c语言差不多的
%s 将内容转换成字符串，放入占位位置
%d 将内容转换成整数，放入占位位置
%f 将内容转换成浮点型，放入占位位置

字符串的格式化的精度控制

跟c语言一样的
Python字符串格式化的精度控制
在Python中，可以使用不同的方法来格式化字符串，并且可以控制浮点数的精度。这通常通过指定小数点后的位数来实现。

使用%操作符

格式化浮点数，保留两位小数
1
2
3
4
value = 3.14159  
formatted_string = "%.2f" % value  
print(formatted_string)  # 输出: 3.14
使用str.format()方法
格式化浮点数，保留两位小数
1
2
3
4
value = 3.14159  
formatted_string = "{:.2f}".format(value)  
print(formatted_string)  # 输出: 3.14

使用f-string（Python 3.6及以上版本）
f-string是一种在Python 3.6及更高版本中引入的新特性，允许在字符串中嵌入表达式。

格式化浮点数，保留两位小数
1
2
3
value = 3.14159  
formatted_string = f"{value:.2f}"  
print(formatted_string)  # 输出: 3.14

在这些例子中，:.2f是一个格式说明符，它告诉Python保留浮点数的小数点后两位。你可以通过改变2来改变小数点后的位数。

如果你想要控制科学计数法中的精度（例如，控制指数部分的小数位数），你可以使用e或E，并在冒号后面加上精度指示符。但是，请注意，这里的精度指的是整个数字（包括指数部分）的小数位数。

格式化浮点数，使用科学计数法并保留两位小数
1
2
3
value = 1234567.89  
formatted_string = "{:.2e}".format(value)  
print(formatted_string)  # 输出: 1.23e+06

使用f-string时，语法是相同的：

格式化浮点数，使用科学计数法并保留两位小数
1
2
3
value = 1234567.89  
formatted_string = f"{value:.2e}"  
print(formatted_string)  # 输出: 1.23e+06

字符串的格式化2

1
2
3
4
# f"{占位}"
name7 = "zzh"
set_up_year = 2001
print(f"f{name7},cs:f{set_up_year}")

对表达式进行格式化

表达式:一条具有明确执行结果的代码语句
如
1+1、5*2，就是表达式，因为有具体的结果，结果是一个数字

1
print(f"1+1={1+1}")

数据输入

input() 输入的信息是字符串类型，如果需要输入数字，需要转换类型

1
2
3
4
5
6
7
8
9
10
11
12
# 获取键盘输入信息

print("输入内容")
name = input()
print("输入的内容为 ： %s" % name)

# 在其中写入提示信息

name1 = input("输入内容")

print(name1)

判断语句

布尔类型和比较运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 布尔类型的定义
bool_1 = True
bool_2 = False
print(type(bool_1))
print(type(bool_2))

# 比较运算符的使用
num1 = 10
num2 = 10

print(num1==num2)

# 不等于

num3 = 10
num4 = 20
print(num3 != num4)

if语句的基本格式

if 要判断的条件：
条件成立时执行的代码块

if else组合判断语句

if 条件 ：
条件成立时执行的代码块
else:
条件不成立时执行的代码块

if elif else组合判断语句

if 条件1：
条件1成立时执行的代码块
else if 条件2：
条件2成立时执行的代码块
else:
条件都不成立时执行的代码块

判断语句的嵌套

if 条件1：
条件1成立时执行的代码块
if 条件2：
条件2成立时执行的代码块
if 条件3：
条件3成立时执行的代码块
if 条件4：
条件4成立时执行的代码块
…………

循环语句

while循环的基础语法

while 循环条件：
循环体
……

1
2
3
4
i = 0
while i<100:
    print(i)
    i = i+1

while循环的的嵌套应用

while 循环条件：
循环体
while 循环条件：
循环体

  • print输出不换行
    1
    2
    print("123",end="")

    \t = tab键（对齐的作用）
1
2
print("Hello\tworld")
print("Hello\nbest")
  • 循环案例实现九九乘法表
    1
    2
    3
    4
    5
    6
    7
    8
    i = 1  
    while i <= 9:  
        j = 1  
        while j <= i:  
            print(f'{j}x{i}={i*j}', end='\t')  
            j += 1  
        print()  
        i += 1

for循环的基本语法

for循环属于轮询机制 是对一批内容进行逐个处理
for 循环变量 in 循环内容：
循环体

  • 例子：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 数一数多少字

    name = "12345"
    num = 0

    for x in name:
        num += 1
        print(x)
    print(num)

range 语句

  • 语法一：
    range(num) # 生成从0开始，到num-1的整数序列
  • 语法二：
    range(num1, num2) # 生成从start开始，到end-1的整数序列
  • 语法三：
    range(num1, num2, step) # 生成从start开始，到end-1，步长为step的整数序列 (step 默认为1)
    如：range(5,10,2) 获取的数据是[5,7,9]

for循环临时变量作用域

for 临时变量 in 待处理数据集：
循环体

临时变量在编码规范上，作用范围（作用域），只限定在for循环内部
如果在for循环外部访问临时变量：

  • 实际上是可以访问到的
  • 在编码规范上是不允许的，不建议这么做的

for循环的嵌套应用

for 循环变量 in 待处理数据集：
循环体
for 循环变量 in 待处理数据集：
循环体

  • 例子：for循环实现九九乘法表
    1
    2
    3
    4
    for i in range(1, 10):  
        for j in range(1, i+1):  
            print(f'{j}x{i}={i*j}', end='\t')  
        print()

continue和break语句

在Python中，continue和break语句用于控制循环（for或while）的流程。

continue 语句
continue语句用于跳过当前循环迭代的剩余部分，并开始下一次迭代。它常用于在循环中根据某些条件跳过某些不需要的操作。

下面是一个使用continue语句的例子，它打印出1到10之间除了5以外的所有数字：

1
2
3
4
for i in range(1, 11):  
    if i == 5:  
        continue  
    print(i)

在这个例子中，当i等于5时，continue语句会被执行，导致循环跳过当前迭代，不执行print(i)，并直接进行下一次迭代。

break 语句
break语句用于立即结束当前循环，跳出循环体，不再执行循环中剩余的代码。

下面是一个使用break语句的例子，它在找到第一个偶数时停止循环：

1
2
3
4
5
for i in range(1, 11):  
    if i % 2 == 0:  
        print(f"Found an even number: {i}")  
        break  
    print(f"{i} is odd.")

在这个例子中，当循环找到一个偶数（即i除以2的余数为0）时，break语句会被执行，循环立即结束，不会打印出1到10之间的其他奇数。

函数

  1. 函数：组织好的，可重复使用的，用来实现特定的功能的代码块
  2. 使用函数的好处是：
  • 将功能封装到函数内，可供随时随地的重复利用
  • 提高代码复用性，减少重复代码

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 统计长度
str1 = "ssdadasd"
str2 = "sdadadfas"
str3 = "dasdasdasdasdas"


def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(count)


my_len(str1)
my_len(str2)
my_len(str3)

函数的基础定义语法

  1. 函数的定义：
    def 函数名(参数列表):
    函数体
    return 返回值

先定义后调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 统计长度
str1 = "ssdadasd"
str2 = "sdadadfas"
str3 = "dasdasdasdasdas"


def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(count)


my_len(str1)
my_len(str2)
my_len(str3)

函数的传入参数

传入参数的功能是：在函数计算的时候，接收外部传入的参数，供函数内部使用

基于函数的定义语法：
def 函数名(传入参数):
函数体
return 返回值

函数的返回值

函数返回值定义语法

  • 所谓函数返回值，就是程序种函数完成事情后，最后给调用者的结果
    def 函数名(参数列表):
    函数体
    return 返回值

  • 调用：
    变量 = 函数名(参数列表)

  • 例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 定义一个函数，完成2数相加的功能
    def add(a, b):
        result = a + b
        return result


    # 返回值
    r = add(1, 2)
    print(r)

函数返回值之None类型

  • 函数返回值的默认值是None，如果函数没有return语句，函数返回值就是None
    可以主动返回None，也可以不返回，不返回就是返回None

  • 例子：

    1
    2
    3
    4
    def add(a, b):
        result = a + b
       
        return None

  • None类型：None = false 可以在if语句中使用

  • 可以初始化内容的变量

函数说明文档

用注释写函数说明文档，内容写在函数体之前

函数的嵌套调用

  • 例子：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def add(a, b):
        result = a + b
        return result
        def sub(a, b):
            result = a - b
            return result
            def mul(a, b):
                result = a * b
                return result

变量在函数种的作用域

变量在函数中的作用域是变量可以生效的范围。根据定义位置的不同，变量作用域分为全局作用域和局部作用域。

全局作用域是最大的作用域，在全局作用域中定义的变量可以在任何地方使用。在一个页面打开的时候，浏览器会自动生成一个全局作用域，这个作用域会一直存在，直到页面关闭，它才被销毁。

局部作用域则是在全局作用域下又开辟出来的一个相对较小的作用域，在局部作用域内定义的变量只能在它所存在的局部范围内使用。在JavaScript中，只有函数能生成局部作用域，每一个函数都相当于一个作用域，其他的都不能生成局部作用域。

在函数内部对一个变量名进行任何类型的赋值（而不是在一个表达式中对其进行引用）都会创建新的变量，并把新创建的变量划定为本地的作用域。这包括赋值语句、import语句、def语句、函数参数名称等。在默认的情况下，函数内创建的所有变量都是与函数的本地命名空间相关联的。这意味着在函数内部定义的变量能够被函数内的代码使用，但不能在函数的外部被引用。

此外，Python为嵌套函数提供了嵌套的命名空间（作用域），使得嵌套在内部的函数内创建的变量名本地化，以便嵌套函数内部使用的变量名不会与嵌套函数外的变量名产生冲突。而且，即使在嵌套的函数已经返回后，嵌套作用域的查找也是有效的，这种行为有时也叫作闭合（closure）函数。

数据容器

数据容器概念

  • Python中的数据容器：
    一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串，数字，布尔等
  • 数据容器根据特点的不同，如：
  • 是否支持重复元素
  • 是否可以修改
  • 是否有序
    分为5类，分别是：
    列表（list）,元组（tuple），字符串（string）,集合（set）,字典（dict）

列表的定义语法

  1. 列表的定义：列表（list）类型，是数据容器的一类
  2. 列表的定义语法：
  • 字面量
    [元素1，元素2，元素3]
  • 定义变量
    变量名称 = [元素1，元素2，元素3]
  • 定义空列表
    变量名称 = []
    变量名称 = list()

列表内的每个数据，称之为元素

  • 以[]作为标识
  • 列表内每个元素之间用逗号 分隔
  • 元素的类型没有任何限制
1
2
3
4
5
6
7
8
9
10
11
12
13
# 使用[]方式定义列表
name_list = ["c", "a", "b"]
print(name_list)
print(type(name_list))

my_list = ["cab", 123, True]
print(my_list)
print(type(my_list))

# 嵌套列表
my_list1 = [[123], ["cab"]]
print(my_list1)
print(type(my_list1))

列表的下标索引

  • 下标索引从0开始
  • 可以从后向前取 -1，-2，-3（从-1开始）
  • 例子：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 列表下标的索引
    name_list = ["tom", "jack", "rose"]
    print(name_list[0])
    print(name_list[1])
    print(name_list[2])

    # 嵌套的取
    print(name_list[0][1])
    print(name_list[1][1])
    # 反向取
    print(name_list[-1])
    print(name_list[-2])
    print(name_list[-3])

列表的常用操作方法

  1. 功能：增删改查
  2. 列表的查询功能（方法）：
  • 查找指定元素在列表的下标，如果找不到，保存valueError
  • 语法：列表名.index(元素)
  • 例子： 
    1
    2
    3
    4
    5
    6
    7
    my_list = ["zzh", "abcd", "python"]
    # 1.1 查找某一个元素在列表内的下标索引
    index = my_list.index("python")
    print(index)
    # 如果查找的不存在 会报错
    index = my_list.index("python1")
    print(index)
  • 修改索引值
    1
    2
    3
    4
    myy_list = ["zzh", "abcd", "python"]
    myy_list[1] = "python1"
    print(myy_list)

  • 插入
    1
    2
    3
    myy_list = ["zzh", "abcd", "python"]
    myy_list.insert(1, "python1")
    print(myy_list)
  • 删除
    语法1：del 列表名[下标]
    语法2：列表名.pop(下标)
    删除某元素在列表中的第一个匹配项
    1
    2
    3
    myy_list = ["zzh", "abcd", "python"]
    myy_list.remove("python")
    print(myy_list)
  • 追加元素：
    只能追加到尾部
    1
    2
    3
    myy_list = ["zzh", "abcd", "python"]
    myy_list.append("python1")
    print(myy_list)
  • 追加元素方式2：
    1
    2
    3
    myy_list = ["zzh", "abcd", "python"]
    myy_list.extend(["python1"])
    print(myy_list)
  • 清空列表：
    1
    2
    3
    myy_list = ["zzh", "abcd", "python"]
    myy_list.clear()
    print(myy_list)
  • 统计列表中某个元素出现的次数：
    1
    2
    3
    myy_list = ["zzh", "abcd", "python", "python", "python"]
    print(myy_list.count("python"))
    print(myy_list.count("python1"))
  • 统计列表中全部元素的个数：
    1
    2
    myy_list = ["zzh", "abcd", "python", "python", "python"]
    print(len(myy_list))

列表的循环遍历

列表的遍历-while循环

1
2
3
4
5
6
7
8
9
10
11
12
myy_list = ["zzh", "abcd", "python", "python", "python"]
i = 0
while i < len(myy_list):
    print(myy_list[i])
    i += 1
    if i == 3:
        break
        print("break")
        i += 1
        print("continue")
        i += 1
        print("continue")

列表的遍历-for循环

1
2
3
4
5
6
7
8
9
myy_list = ["zzh", "abcd", "python", "python", "python"]
for i in myy_list:
    print(i)
    if i == "python":
        print("continue")
        continue
        print("break")
        break
        print("break")

元组

  • 元组（tuple）是数据容器的一种，是列表（list）的另一种形式，但是和列表（list）不同的是：元组（tuple）是不允许修改的，一旦定义，就不能再修改。元组（tuple）的定义语法和列表（list）的定义语法类似，但是元组（tuple）中不能使用方括号，只能使用圆括号，而且元组（tuple）中不能使用重复元素。

  • 元组一旦定义完成，就不可修改（只读的list）

  • 元组的定义语法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 定义元组字面量
    ("元素1", "yuansu2", "yuansu3")
    t2 = ()
    t3 = tuple()
    # 定义单个元素的元素，后面要加逗号，否则类型为str
    t4 = ("hell",)
    # 元组的嵌套
    t5 = ((1, 2, 3), (4, 5, 7))
    print(f"{type(t5)}")

  • 元组的操作方法：

    • index 查找某个元素
    • count 统计某个元素出现的次数
    • len 统计元组中元素的个数

  • 注意：
    元组的内容不能修改，会报错

    但是可以修改元组内list 的内容

    1
    2
    3
    4
    t9 = (1, 2, ["abc", "efg"])
    print(f"{t9}")
    t9[2][0] = "fffff"
    print(f"{t9}")

字符串

  • 字符串是字符的容器，一个字符串可以存放任意数量的字符
  • 字符串支持下标索引
  • 字符串是一个无法修改的容器

index方法：查找字符串中某个字符在字符串中的下标，如果找不到，保存valueError
replace方法：替换字符串中的某个字符
split方法：将字符串按某个字符分割成多个字符串
strpr方法：将字符串中的空格去除
strip方法：将字符串两端的空格去除

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

数据容器（序列）的切片

  • 序列支持切片，即：列表，元组，字符串，均支持切片操作
  • 切片语法：
    序列[起始下标：结束下标：步长]
    表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
  • 起始下标表示从何处开始，可以留空，留空视作从头开始
  • 结束下标表示取到什么位置，可以留空，留空视作取到尾部
  • 步长表示，依次取元素的间隔
    • 步长1表示，一个个取元素
    • 步长2表示，每两个取一个元素
    • 步长为负数，表示从尾部开始取元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]
print(result1)
# 对tuple进行切片，从头开始，到最后结束，步长为1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[1:4]
print(result2)

# 对字符串切片，从头开始，到最后结束 步长为2
my_str = "0123456"
result3 = my_str[::2]
print(result3)

# 反向步长-1
.....

集合

  • 列表，元组，都支持重复的元素，不方便进行去重复处理，集合主要的特点为不支持重复元素
  • 集合的定义语法：
  • 定义集合字面量
    {元素1，元素2，元素3}
  • 定义集合变量
    变量名称 = {元素1，元素2，元素3}
  • 定义空集合
    变量名称 = set()

集合的操作方法：

  • 添加新元素：
    myyset.add(元素)
  • 删除元素：
    myyset.remove(元素)
  • 随机取出一个元素：
    myyset.pop()
  • 清空集合：
    myyset.clear()
  • 取2个集合的差集：
    set3 = set1.difference(set2)
  • 消除两个集合的差集：
    set3 = set1.difference_update(set2)
  • 2个集合合并为1个：
    set3 = set1.union(set2)
  • 统计集合元素的数量：
    len(myyset)
  • 集合的遍历：
    不支持下标索引，不支持while循环
    但是支持for循环

字典

字典可以通过键来访问值
例如 可以通过学生姓名检索学生的成绩

  • 字典的定义语法：

  • 定义字面量
    {key:value,key:value,key:value}

  • 定义字典变量
    变量名 = {key:value,key:value,key:value}

  • 定义空字典
    变量名 = dict()
    变量名 = {}

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

    1
    2
    3
    4
    5
    6
    # 语法：字典[key]可以取得对应的value
    stu_score = {"www": 99,"yx666":88,"fun":77}
    print(stu_score["www"])
    print(stu_score["yx666"])
    print(stu_score["fun"])

  • 字典的嵌套
    字典的key和value可以是任意数据类型（Key不可为字典）
    则value可以是字典

字典的常用操作

  • 新增元素：
  • 字典[key] = value 
    1
    2
    3
    4
    5
    6
     # 新增元素
    stu_score = {"www": 99, "yx666": 88, "fun": 77}

    stu_score["zzh"] = 666
    print(stu_score)

  • 更新元素：
  • 字典[key] = value 
    1
    2
    3
     # 更新元素
    stu_score["www"] = 111
    print(stu_score)
  • 删除元素：
  • pop(key) 获得指定key的value，同时字典被修改，指定Key的数据被删除
    1
    2
    3
    4
    value = stu_score.pop("www")
    print(value)
    print(stu_score)

  • 清空字典：
  • 字典.clear() 
    1
    2
    stu_score.clear()
    print(stu_score)
  • 获取字典全部的key
  • 字典.keys() 
    1
    2
    3
     # 获取全部的key
    keys = stu_score.keys()
    print(keys)
  • 遍历字典
  • 不支持下标索引，不支持while循环
  • 支持for循环
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 遍历字典
    # 方式1：通过获取到全部key来完成遍历
    for key in keys:
        print(key)
        print(stu_score[key])

    # 方式2：直接对字典进行for循环，每次循环都是直接得到key
    for key in stu_score:
        print("*")
        print(key)
        print(stu_score[key])

  • 统计字典内的元素数量，len（）函数
    1
    2

    print(len(stu_score))

类数据容器的总结对比

字符串比较大小

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大

函数进阶

函数的多返回值

1
2
3
4
5
6
7
8
# 函数多返回值示例
def test_def():
    return 1, 2


x, y = test_def()
print(x)
print(y)

函数的多种参数使用形式

位置参数

调用函数时根据函数定义的参数位置来传递参数

1
2
3
4
5
def user_info(name, age, gender):
    print(f"{name, age, gender}")


user_info("tom", 20, "男")

注意：传递参数和定义的参数的顺序及个数必须一致

关键字参数

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

1
2
3
4
5
6
7
8
9
10
def user_info(name, age, gender):
    print(f"{name, age, gender}")


# 关键字传参
user_info(name="aaaa", age=20, gender="男")
# 可以不按照固定顺序
user_info(age=20, gender="女", name="bbb")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("ccc", age=20, gender="nan1")

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

缺省参数

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

1
2
3
4
5
6
def user_info(name, age, gender="男"):
    print(f"{name, age, gender}")


user_info("tom", 20)
user_info("Rose", 18, "女")

注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数

不定长参数：不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
作用：当调用函数时不确定参数个数时，可以使用不定长参数

不定长参数的类型：

  1. 位置传递
1
2
3
4
5
6
def userinfo(*args):
    print(args)

userinfo("tom")
userinfo(1111111)
userinfo("tom",1111,"sddsasd")

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组
类型，这就是位置传递

  1. 关键字传递
    1
    2
    3
    4
    5
    def user_info(**kwargs):
        print(kwargs)


    user_info(name="tom", age=18, id=110)

注意：参数是“键=值” 形式的形式的情况下，所有的“键= 值”都会被kwargs接收，同时会根据“键= 值”组成字典

函数作为参数传递

1
2
3
4
5
6
7
8
9
10
# 函数作为参数
def test_func(compute):
    result = compute(1,2)
    print(f"{type(compute)}")
    print(f"{result}")

def compute(x,y):
    return x+y

test_func(compute)

lambda匿名函数

  • 函数定义中：

    • def 关键字，可以定义带有名称的函数
    • lambda 关键字，可以定义匿名函数（无名称）
      有名称的函数，可以基于名称重复使用
      无名称的函数，只可临时使用一次

  • lambda函数的定义：
    lambda 传入参数：函数体（一行代码）

  • lambda是关键字，表示定义匿名函数

  • 传入参数表示匿名函数的形式参数，如：x,y表示接收2个形式参数

  • 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

1
2
3
4
5
6
7
# 实例
def test_func(compute):
    result = compute(1,2)
    print(f"{type(compute)}")
    print(f"{result}")

test_func(lambda x,y:x+y)

文件操作

文件的编码概念

UTF-8 GBK Gig5

文件的读取操作

  • open()打开函数：
    语法： open(file_name, mode，encoding)
    name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
    mode:设置打开文件的模式（访问模式）：只读，写入，追加
    encoding:设置打开文件的编码格式（推荐使用UTF -8）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 打开文件

f = open("地址", "r", encoding="UTF-8")
# 读取文件-read()，读取十个字节
f.read(10)
print(f"读取10个字节的结果:{f.read(10)}")
print(f"read方法读取全部内容的结果是：{f.read()}")

# 读取文件 - readLines（）
f.readlines()  # 读取文件的全部行

# 关闭文件对象
f= open("1111")
f.close()

# with open()语句后自动关闭

正则表达式

原子：
组成的最小单元，所有可见的字符都是原子：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,0123456789_
所有不可见字符也都是原子：\t\n\r\f\v
正则专用转义字符：
/d 表示0-9之间的数字–》[0123456789]
/D 表示非0-9之间的数字
/s 表示空白字符（不可见字符 ） ->[\t\n\r\f\v]
/S 表示非空白字符（可见字符）-》 [^\t\n\r\f\v]
/w 表示0-9、a-z、A-Z、之间的字符 ->[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]
/W 表示非0-9、a-z、A-Z、_之间的字符
. 表示任意字符，除了换行符

元字符[原子修饰符]
需要0-9中奇数组成的原子 1，3，5，7，9
[] 自定义原子列表
表示自定义原子列表中的任意一个字符，如果多个字符在ascii码中是连续的，可以进行缩写[0-9]
[] 自定义排除列表
[^] 表示自定义排除列表
[^0-9] 表示非0-9之间的字符
与数字相关的元字符
+ 表示1个或者多个
* 表示任意一个
? 表示0个或者1个
{n,m} 表示n-m个
{m,}表示m个到正无穷
{,n}表示0-n个

re 模块:正则表达式专用模块
\A 表示字符串的开头
\Z 表示字符串的结尾
\b 表示单词的开头和结尾（词边界）汉字作为字母处理
\B 表示非单词的开头和结尾（词边界）
^ 表示字符串的开头，支持多行模式
$ 表示字符串的结尾，支持多行模式
| 表示选择关系（或）左右内容二选一 非常重要
() 表示分组，分组可以提取子串，也可以进行条件判断(改变正则表达式的匹配关系)
2.将多个原子视为一个原子处理

多行模式：如果字符串中包含\n,则可以在匹配的时候使用多行匹配模式，多行匹配模式
注意：多行模式需要使用模式修正符