【无痛学Python】基础语法3

于 2025-06-07 11:59:12 发布
阅读量963 收藏 21
点赞数 14
CC 4.0 BY-SA版权
分类专栏： Python 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Skrrapper/article/details/148493385

【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])

    结果如下：

    image-20250306152117999

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

遍历列表元素

  • 使用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))

    image-20250306152940106

删除元素

使用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()

集合的应用场景

  1. 去重（列表转集合去重）

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

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

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

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

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

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

    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()


------

## **集合的应用场景**

1. **去重**（列表转集合去重）

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

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

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

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

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

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

    data = {(1, 2), (2, 3), (1, 2)}
print(data)  # {(1, 2), (2, 3)} 自动去重
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Skrrapper

谢谢你的支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值