python组合数据类型与函数参数

原创已于 2025-03-14 12:51:19 修改 · 1k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#python #vscode #开发语言

于 2025-03-14 00:38:16 首次发布

一、数据类型

不可变数据类型：整型、浮点数、字符串、元组tuple（只要元组中的所有元素都是不可变类型，元组也可以作为集合的元素）

可变数据类型：列表list、字典dict、集合set

1. 集合类型

建立集合类型用 {} 或 set()。建立空集合类型，必须使用set()

集合是多个元素的无序组合，集合元素之间无序，每个元素唯一，不存在相同元素。

集合元素不可更改，不能是可变数据类型。

哈希值的稳定性：

集合通过元素的哈希值来快速查找和存储元素。哈希值必须是稳定的，即在对象的生命周期内不能改变。

如果集合中的元素是可变的，那么元素的哈希值可能会在对象被修改后发生变化，这会导致集合无法正确地找到和管理这些元素。

去重机制：

集合的去重机制依赖于元素的哈希值和相等性比较。

如果元素是可变的，那么在对象被修改后，集合可能会认为两个不同的对象实际上是相同的，从而导致去重失败。

常用操作：交并差补包含等

常用函数

S.add(x)

S.discard(x)

S.remove(x)

len(S)

x in S

x not in S

set(x)

集合类型应用场景：

成员检测：包含关系比较 "p" in {"p", "y" , 123} {"p", "y"} >= {"p", "y" , 123}

元素去重：集合类型所有元素无重复：将list转为set，再转为list即可，如

ls = []

s= set(ls)

ls = list(s)

2. 序列

序列是一个基类类型，包括字符串、元组、列表类型

常用操作符

x in s

x not in s

s + t

s*n 或 n*s

s[i]

s[i: j] 或 s[i: j: k]

len(s)

min(s)

max(s)

s.index(x) 或s.index(x, i, j)

s.count(x)

列表类型

列表用[]和list()创建

列表中各元素类型可以不同，无长度限制

方括号 [] 真正创建一个列表，赋值仅传递引用

常用操作

ls[i] = x

ls[i: j: k] = lt

del ls[i]

del ls[i: j: k]

ls += lt

ls *= n

常用函数

ls.append(x)

ls.clear()

ls.copy()

ls.insert(i,x)

ls.pop(i)

ls.remove(x)

ls.reverse()

有序操作：使用 ls.sort() 或 sorted() 方法进行列表排序

元组类型

元组是一种序列类型，一旦创建就不能被修改

小括号 () 或 tuple() 创建

可以使用或不使用小括号

def func():

return 1,2

Tp = "cat", "dog", "tiger"

Tonly = ( 2 , ) 只有一个元素时，逗号不能省略，若么有逗号是

<class 'int'>，有了后就是<class 'tuple'>

字典类型

字典是键值对的集合，键值对之间无序

采用大括号{}和dict()创建，键值对用冒号: 表示

[ ] 用来向字典变量中索引或增加元素

常用函数或方法

k in d k是否是d的键

del d[k]

d.keys()

d.values()

d.items()

d.get(k, <default>)

d.pop(k, <default>)

d.popitem()

d.clear()

len(d)

二、函数参数

组合数据类型，如果局部变量未真实创建，则是全局变量

默认参数

# 默认参数, 默认参数必须放在非默认参数后面
def myfunc0(x,y=1):
   x = x + y
   return x
print(myfunc0(10))

可变参数

# 可变参数
def myfunc1(*args):
    print(args)
    for i in args:
        print(i)
myfunc1(1,2,3,4,5)

关键字参数

# 关键字参数 : 可给函数传递键值对（指定关键字和值的多组参数）
def myfunc2(**kwargs):
    print(kwargs)
    for key in kwargs:
        print(key,kwargs[key])
myfunc2(a=1,b=2,c=3)
kv = {"a":1,"b":2,"c":3}
myfunc2(**kv)   #使用 **kv 时，Python 会将字典解包，把键作为参数名，值作为参数值，传递给函数 myfun2

命名关键字参数

# 命名关键字参数
def myfunc3(name,*,age,city):   # * 表示后面所有的参数都是关键字参数
    print(name,age,city)
myfunc3("xiaoming",age=18,city="beijing")
#myfunc3("xiaoming",18,"beijing")  这就是错误的，后两个不是命名关键字参数

混合参数

#混合参数
def myfunc4(a,b=0,*c,d,**e):
    print(a,b,c,d,e)
kv = {"k1":2,"k2":4}
myfunc4(1,2,3,4,5,d=6,**kv)

三、实参与形参

# 调用函数时，如果实参使用常量，形参值为常量值的副本；如果实参使用变量，形参值为变量的值的引用，也就是形参和实参指向同一块内存地址，直到给形参重新赋值或改变简单类型形参值时，才会触发给形参创建独立的内存空间

第一个示例：

def myfunc5(a,b):
    print(id(a))
    print(id(b))
    a = 10
    b = 20
    print(id(a))
    print(id(b))
a = 1
b = 2
myfunc5(a,b)
print("调用函数结束")
print(a,b)
print(id(a))
print(id(b))
print("**************")

第二个示例：

def myfunc6(a,b,c):
    a = a + 1
    b.append(1)
    c = [5,6]
    print("a地址：",id(a))
    print("b地址：",id(b))
    print("c地址：",id(c))
x = 2
y = [1,2]
z = [3,4] 
print("调用前")
print(x,y,z)
print("x地址：",id(x))
print("y地址：",id(y))
print("z地址：",id(z))

myfunc6(x,y,z)

print("调用后")

print(x,y,z)
print("x地址：",id(x))
print("y地址：",id(y))
print("z地址：",id(z))
print("**************")

以上内容参考自：python语言程序设计基础-第三版，嵩天著

python网络编程(Linux)-赵宏编著