【0基础学Python】基础语法Part3

Skrrapper

发布于 2025-03-15 21:04:19

15300

代码可运行

文章被收录于专栏：技术分享技术分享

运行总次数：0

代码可运行

【Python】基础语法3

函数

创建函数/定义函数

def 函数名(形参列表)
	函数体
	return 返回值

调用函数

函数名(实参列表)          # 不考虑返回值时
返回值 = 函数名(实参列表)  # 考虑返回值时

函数必须先定义再调用；如果仅仅定义而不调用，则不会执行该函数

def test1():
    print('hello')  
# 如果光是定义函数, 而不调用, 则不会执行

test3()          
def test3():
    print('hello')
# 还没有执行到定义, 就先执行调用了, 此时就会报错.

函数参数

在函数定义的时候, 可以在 ( ) 中指定 “形式参数” (简称形参), 然后在调用的时候, 由调用者把 “实际参数” (简称实参) 传递进去.

这样可以做到一个函数多次使用。

def calcSum(beg,end)
	sum = 0
	for i in range(beg,end+1)
		sum += 1
	print(sum)
	
calcSum(1,100)
calcSum(2,200)
calcSum(3,300)

函数可以有一个形参、也可以有多个形参，也可以没有

一个函数的形参有几个，就要传几个实参

Python中函数信产不必指定参数类型，也就是说一个函数可以支持多种不同类型的参数

def test(a):
    print(a)
test(10)
test('hello')
test(True)

函数返回值

返回值的存在有一个意义：实际开发中我们的一个通常的编程原则, 是 “逻辑和用户交互分离”. 如果我们使用返回值将函数返回，那么就可以将用户和函数逻辑进行分离，也就是实现函数的封装，从而使得用户可以更清晰使用函数同时进行保密工作。

def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    print(sum)
    
calc(1, 100)

转换成下面更好

def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    return sum
result = calcSum(1, 100)
print(result)

这两个代码的区别就在于：

前者直接在函数内部进行了打印,而第一种写法的函数中, 既包含了计算逻辑, 又包含了和用户交互(打印到控制台上)；

后者则使用 return 语句把结果返回给函数调用者, 再由调用者负责打印.专注于做计算逻辑, 不负责和用户交互. 那么就很容易把这个逻辑搭配不同的用户交互代码, 来实现不同的效果.

一个函数可以有多个return语句
执行到return语句，函数执行结束，回到调用位置
一个函数可以一次返回多个返回值

变量作用域

形参和实参名字可以相同，但是代表的意义不一样。

如果想在函数内部修改全局变量的值，就是用global关键字进行声明

x = 20
def test():
    global x # 使用global将其变为全局变量
    x = 10
    print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}')

函数的用法

嵌套调用：一个函数中可以调用其他的函数
链式调用：把一个函数的返回值作为另一个函数的参数
函数递归：在一个函数中调用自己（嵌套调用的特殊用法）递归务必保证：存在递归结束条件；保证函数的实参逐渐接近结束条件

参数默认值

Python 中的函数, 可以给形参指定默认值.

带有默认值的参数, 可以在调用的时候不传参.

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y
print(add(10, 20))      # 此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.
print(add(10, 20, True))# 如果指定参数值，则不再使用默认值

关键字参数

如果没有按照顺序来写参数，则可以使用关键字参数来显式指定要传给哪个实参

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')
test(x=10, y=20)
test(y=100, x=200)

列表和元组

列表和元组是什么

列表、元组是在代码中批量表示/保存数据的方式

二者的区别：

列表中可以修改调整表中的元素
元组中的元素是创建元组时就设定好的，无法修改

列表

alist = [] # 第一种书写方式 
alist = list() # 第二种书写方式
printf(type(alist))

列表中存放的元素允许是不同类型
列表中可以存放初始值

访问

如果想要访问列表中的某个元素，可以使用[]下标访问符进行访问

alist = [1,2,3,4]
print(alist[2])# 下标从0开始，故这里打印3
print(alist[19])# 如果超出列表有效范围，则抛出异常
print(len(alist))# 获取列表长度
print(alist[-1])# 负数输出倒数第几个元素

切片操作

通过切片可以取出一组连续的元素，即取出一个子列表

alist = [1,2,3,4]
print(alist[1:3])# 取出一组连续元素，打印[2,3]

取出的[a,b]是一个前闭后开区间。

切片操作可以省略前后边界

alist = [1,2,3,4]
print(alist[1:])# 省略后边界, 表示获取到列表末尾 打印[2,3,4]
print(alist[:-1]) # 省略前边界, 表示从列表开头获取 打印[1,2,3]
print(alist[:])# 省略两个边界, 表示获取到整个列表 打印[1,2,3,4]

还可以指定步长，也就是“每访问一个元素后，下标自增几步”

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])

结果如下：

如果切片中填写的数字越界了，不会有负面效果。只会尽可能的把满足条件的元素打印。

遍历列表元素

使用for循环

alist = [1,2,3,4]
for elem in alist:
	print(elem)

使用for按照范围生成下标，按照下标访问

alist = [1,2,3,4]
for i in range(0,len(alist))
	print(alist(i))

使用while控制

alist = [1, 2, 3, 4]
i = 0
while i < len(alist):
    print(alist[i])
    i += 1

查找元素

使用in操作符，判定元素是否在列表中存在，返回布尔类型

alist =[1,2,3,4]
print(2 in alist)# Ture
print(10 in alist)# False

使用index方法，查找元素在列表中的下标，返回值是一个整数；若元素不存在，则抛出异常

alist = [1,2,3,4]
print(alist.index(2))
print(alist.index(10))

删除元素

使用pop方法来进行删除操作。

alist = [1, 2, 3, 4]

删除最末尾元素

alist.pop()# pop中不放东西就是默认删除最末尾元素

按照下标删除元素

alist.pop(2)# pop中放入下标

使用remove方法按照值来进行删除操作

alist.remove(2)# 删除了2这个元素，而不是以2为下标的元素

连接列表

使用+将两个列表连接；注意此处的结果会产生一个新列表，而不会影响原来旧的列表

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)

使用extend方法, 相当于把一个列表拼接到另一个列表的后面；注意会影响到被拼接的表

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)# 将blist的内容拼接到alist的末尾，所以会影响list
print(alist)
print(blist)

元组

元组使用()表示

atuple = ()
atuple = tuple()

元组不能改变里面的元素。

所以对于写操作、修改冤死、新增元素等对于元素集合会有改变的操作，都不支持。

元组在很多时候就是默认的集合类型

def getPoint():
    return 10, 20
result = getPoint()
print(type(result))# 这里的类型是元组tuple

元组和列表的对比

元组更安全，可以防止未知的函数打乱列表数据
列表可操作性更高
字典对于键必须是可hash对象，前提是不可变，也就会用到元组。

字典

字典的意义

字典是一种存储 键值对 的结构

键值对

键Key

值Value

key和value意义映射，通过key快速找到value

创建字典

创建空字典

//创建空字典
a= {}
b= dict{}

指定初始值

//指定初始值
student = {'id': 1, 'name': 'zhangsan'}

常常为了美观，会分行书写

student = {
	'id': 2,
	'name': 'lisi',
}

最后一个键值对的,可以写也可以不写

student = {
	'id': 2,
	'name': 'lisi'  //这里的,可以不写
}

查找key

使用in判定指定的key是否存在于字典中，返回布尔值

student = {
 'id': 1,
 'name': 'zhangsan',
 }
 print('id' in student) // 返回True
 print('score' in student) // 返回False

使用[ ]获取到元素的值，[ ]中的下标是key。

student = {
 'id': 1,
 'name': 'zhangsan',
 }
 print(student['id']) // 1
 print(student['name']) // zhangsan

若key在字典中不存在，则会抛出异常

student = {
 'id': 1,
 'name': 'zhangsan',
 }
 print(student['score'])

新增/修改元素

可以使用[ ]来根据key新增/修改value

若key不存在，则新增键值对

student = {
 'id': 1,
 'name': 'zhangsan',
 }
 student['score']
 print(student)

若key存在，则修改键值对的值

student = {
 'id': 1,
 'name': 'zhangsan',
 'score': 80
 }
 student['score'] = 90
 print(student)

删除元素

使用pop根据对应的键值对

student = {
 'id': 1,
 'name': 'zhangsan',
 'score': 80
 }
 student.pop('score')
 print(student) // 删除了score的键值对

遍历元素

使用for循环可以获取所有的key和值

student = {
'id': 1,
 'name': 'zhangsan',
 'score': 80
}

for key in student:
	print(key,student[key])

取出所有key和value

取出所有key使用`keys`方法

student = {
 'id': 1,
 'name': 'zhangsan',
 'score': 80
 }
 print(student.keys()) // 打印dict_keys(...)

取出所有value使用`values`方法

student = {
 'id': 1,
 'name': 'zhangsan',
 'score': 80
 }
 print(student.values()) // 打印dict_values(...)

取出所有键值对使用`items`方法

student = {
 'id': 1,
 'name': 'zhangsan',
 'score': 80
 }
 print(student.items()) // 打印dict_items(...)

合法的key类型

不是所有类型都可以作为key，字典本质上是 哈希表，所以类型应该是“可哈希的”，也就是可以计算出一个哈希值。即满足：可以使用 hash 函数计算某个对象的哈希值。

 print(hash(0))
 print(hash(3.14))
 print(hash('hello'))
 print(hash(True))
 print(hash(()))           
# ( ) 是一个空的元组

列表、字典无法计算哈希值

print(hash([1,2,3])) // 返回错误
pirnt(hash({'id',1})) // 返回错误

集合

Python 中的 集合（set） 是一种无序、不重复 的数据结构，支持高效的成员关系测试和集合运算。

创建集合

使用 `{}` 创建集合

s = {1, 2, 3, 4, 5}
print(s)  # {1, 2, 3, 4, 5}

注意：{} 不能创建空集合，{} 代表 空字典。

使用 `set()` 创建集合

s = set([1, 2, 3, 4, 5])  
print(s)  # {1, 2, 3, 4, 5}

empty_set = set()  # 创建空集合
print(empty_set)  # set()

集合的特点

无序性：集合中的元素没有固定顺序，无法通过索引访问。
不重复：集合自动去重。
可变性：集合本身可变（可增删元素），但其中的元素必须是不可变类型（如 int、str、tuple 等）。

示例：

s = {1, 2, 2, 3, 4, 4}
print(s)  # {1, 2, 3, 4} 自动去重

集合的基本操作

添加元素

s = {1, 2, 3}
s.add(4)  # 添加单个元素
print(s)  # {1, 2, 3, 4}

s.update([5, 6, 7])  # 添加多个元素
print(s)  # {1, 2, 3, 4, 5, 6, 7}

删除元素

s.remove(2)  # 删除元素 2，若不存在会报错
print(s)  # {1, 3, 4, 5, 6, 7}

s.discard(3)  # 删除元素 3，若不存在不会报错
print(s)  # {1, 4, 5, 6, 7}

s.pop()  # 随机删除一个元素
print(s)  # 可能删除任意一个元素

s.clear()  # 清空集合
print(s)  # set()

集合的应用场景

去重（列表转集合去重）

lst = [1, 2, 2, 3, 4, 4, 5]
unique_lst = list(set(lst))
print(unique_lst)  # [1, 2, 3, 4, 5]

成员测试（去除 O(n) 复杂度的搜索）

nums = {1, 2, 3, 4, 5}
print(3 in nums)  # True
print(10 in nums)  # False

数学运算（交集、并集、差集）

common_students = students_set_1 & students_set_2  # 计算共同学生

去除不可变元素组合中的重复项

data = {(1, 2), (2, 3), (1, 2)}
print(data)  # {(1, 2), (2, 3)} 自动去重
print(s)  # {1, 4, 5, 6, 7}
s.pop()  # 随机删除一个元素
print(s)  # 可能删除任意一个元素
s.clear()  # 清空集合
print(s)  # set()

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-03-14，如有侵权请联系 cloudcommunity@tencent.com 删除

函数

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度