【零基础学python】python高级语法（四）

接续上面的系列文章：

【零基础学python】python基础语法（一）-CSDN博客

【零基础学python】python基础语法（二）-CSDN博客

【零基础学python】python高级语法（三）-CSDN博客

---

 

目录

2，字典

3，集合

4，函数

---

2，字典

• 字典初始

【1】字典的创建与价值

字典(Dictionary)是一种在Python中用于存储和组织数据的数据结构。元素由键和对应的值组成。其中，键(Key)必须是唯一的，而值(Value)则可以是任意类型的数据。在Python 中，字典使用大括号0来表示，键和值之间使用冒号:进行分隔，多个键值对之间使用逗号,分隔。

info = {"name":"yuanhao", "age":20, "height":120} 
print(type(info)) #<class 'dict'> 
del info["name"] 
print(info) 
info["wkrgfwk"] = "zhege" 
print(info)

• 字典的存储与特点

hash:百度百科

Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入(又叫做预映射pre-image)通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

字典对象的核心其实是个散列表，而散列表是一个稀疏数组(不是每个位置都有值),每个单元叫做bucket,每个bucket有两部分:一个是键对象的引用,一个是值对象的引用，由于,所有bucket结构和大小一致,我们可以通过偏移量来指定bucket的位置

字典的特点:

无序性:字典中的元素没有特定的顺序，不像列表和元组那样按照索引访问。

通过键来访问和操作字典中的值。

键是唯一的且不可变类型对象:用于标识值。值可以是任意类型的对象，如整数字符串、列表、元组等。

可变性:可以向字典中添加、修改和删除键值对。这使得字典成为存储和操作动态数据的理想选择。

info = {"name":"yuanhao", "age":20, "height":120} 
print(bin(hash("age"))) 
#十进制转换成二进制 
#键的要求 #1，字符串 #2，数字 #3，元组 #4，布尔值

• 字典的基本操作

# 使用{}创建字典 
gf ={"name":"高圆圆","age":32} 
print(len(gf)) #(1)查键值 
print(gf["name"]) #高圆圆 
print(gf["age"]) #32 
#(2)添加或修改键值对 注意:如果键存在，则是修改，否则是添加 
gf["age"] = 29          # 修改键的值 
gf["gender"〕= "female" # 添加键值对 
#(3)删除键值对 del 删除命令 
print(gf) 
del gf["age" ] 
print(gf) 
del gf 
print(gf) 
#(4)判断键是否存在某字典中
print("weight" in gf) 
#(5)循环 
for key in gf: print(key,gf[key])

Python 字典中键(key)的名字不能被修改，我们只能根据键(key)修改值(value)

• 字典的内置方法

gf ={"name":"高圆圆","age":32} 
#(1)创建字典 
knowledge =〔'语文'，'数学'，'英语'] 
scores= dict.fromkeys(knowledge,60) 
print(scores) 
#(2)获取某键的值 
print(gf.get("name"))    #高圆圆 
#(3)更新键值:添加或更改 
gf.update({"age":18,"weight":"50kg"}) 
print(gf) #{'name':'高圆圆','age':18,'weight':'50kg'} 
#(4)删除weight键值对14 
ret = gf.pop("weight")   # 返回删除的值 
print(gf) 
#(5)遍历字典键值对 
for k,v in gf.items(): print(k,v)

• 可变数据类型之字典

#列表字典的存储方式 
l = [1,2,3] 
d = {"a":1, "b":2} 
#案例1 
l1 = [3, 4, 5] 
d1 = {"a":1, "b":2, "c":l1} 
l1.append(6) 
print(d1) 
d1["c"][0] = 300 
print(l1) 
#案例2 
d2 = {"a":1, "b":2, "c":3} 
d3 = {"x":12, "y":11, "z":d2} 
d2["z"] = 30 
print(d3) 
d3["z"].update({"z":30}) 
#为d3中增加d2中的成员{"z":30} 
print(d3) 
d3["z"]["a"] = 100 #等价于 
d3["z"].update("a":100) 
print(d2) 
d3["z"] = 100 
print(d3) 
#案例3 
d4 = {"x":10, "y":20} 
l2 = [1, 3, d4] 
d4["z"] = 30 
print(d4) #{'x': 10, 'y': 20, 'z': 30} 
l2[2].pop("y") 
print(d4) # {'x': 10, 'z': 30}

3，集合

• 集合的基本操作

集合(Set)是Python中的一种无序、不重复的数据结构。集合是由一组元素组成的，这些元素只能是不可变数据类型的，在集合中每个元素都是唯一的，即集合中不存在重复的元素。

# 集合内的元素必须是不可变的数据类型 
s1 = {1,2,3} 
print(len(s1)) 
print(type(s1)) 
#set类型的数据 
#(1)无序:没有索引 
print(s1) 
#(2)唯一:集合可以去重 
s2={1,2,3,3,2,2} 
print(s2) 
#面试题----将列表去重 
l = [1,2,3,3,2,2] 
#类型转换:将列表转为set 
print(set(l)) 
#{1，2，3} 
print(list(set(l))) #[1，2，3] 
#(3)可变类型 列表、字典与集合 
s1 = {1,2,3} 
#内置方法 
#添加 
s1.add(5) 
print(s1) 
s1.update({1,2,3,4,6}) #需要更新再次加上一个集合类型的 
print(s1) 
#删除 
s1.remove(5) 
print(s1) 
s1.discard(5) 
#当删除的元素不存在的时候discard不会报错，而使用remove会导致报错的问题 
print(s1) 
s1.pop() #删除并返回任意的一个集合元素 
print(s1) 
s1.clear() #清空集合内的元素 
print(s1)

无序性:集合中的元素是无序的，即元素没有固定的顺序。因此，不能使用索引来访问集合中的元素。

唯一性:集合中的元素是唯一的，不允许存在重复的元素。如果尝试向集合中添加已经存在的元素，集合不会发生变化。

可变性:集合是可变的，可以通过添加或删除元素来改变集合的内容

• 集合高级操作

s1 = {1,2,3,4} 
s2 = {3,4,5,6} 
#方式1，交集& 差集- 并集| 
print(s1 & s2) 
print(s1 | s2) 
print(s1 - s2) 
#剩下s1有s2没有的 
#方式2, 集合的内置方法 
s3 = s1.intersection(s2) 
#交集 
print(s3) 
s3 = s1.union(s2) 
#并集 
print(s3) 
s3 = s1.difference(s2) 
#差集 
print(s3) 
s3 = s1.symmetric_difference(s2) 
#对称差集 print(s3)

4，函数

• 函数的初识

一个程序有些功能代码可能会用到很多次，如果每次都写这样一段重复的代码，不但费时费力、容易出错，而且交给别人时也很麻烦，所以编程语言支持将代码以固定的格式封装(包装)成一个独立的代码块，只要知道这个代码块的名字就可以重复使用它，这个代码块就叫做函数(Function)

函数的本质是一功能代码块组织在一个函数名下，可以反复调用。

去重 (函数可以减少代码的重复性。通过将重复的代码逻辑封装成函数，可以避免在不同的地方重复编写相同的代码)

解耦 (函数对代码的组织结构化可以将代码分成逻辑上独立的模块，提高代码的可读性和可维护性，从而实现解耦）

""" 
函数声明 一次声明 
def 函数名(): 函数体 函数调用 多次调用 
函数名() 
"""

在编程中，函数的参数指的是函数定义中声明的变量，用于接收函数调用时传递的数据。参数允许我们将值或引用传递给函数，以便在函数内部使用这些值进行计算、操作或处理。

函数参数可以有多个，每个参数都有一个名称和类型。函数定义中的参数称为形式参数(或简称为形参)，而函数调用 时传递的实际值称为实际参数(或简称为实参)

函数的参数允许函数在不同的上下文中接收不同的数据，并且增加了函数的灵活性和可复用性。通过合理使用函数参数，可以编写出更通用、灵活的函数。

分为默认参数、位置参数、关键字参数与可变参数

# 函数的参数 
def 函数名(函数参数): 函数体 
""" 
1,函数声明 一次声明 
def 函数名(): 函数体 return 任意类型 #默认返回None 
2,函数调用 多次调用 
函数名() 
3,函数的参数 
def 函数名(函数参数): 函数体 
""" 
""" 
3.1 位置参数----函数形参与实参要必须一一对应 
def 函数名(形参1,形参2,...): 函数体 
函数调用 函数名(实参1,实参2,...) 
""" 
def demo(x,y): print(x+y) 
demo(1,2) 
""" 
3.2 默认参数----函数数声明时默认参数是为参数指定默认值，如果在函数调用时没传递该参数函数，将使用默认值 ----注意:默认参数必须放在位置参数的后面 
def 函数名(形参1 = 默认参数,形参2,...): 函数体 
函数调用 
函数名(实参1,实参2,...) 
""" 
def demo(x,y=10): print(x+y) demo(100) 
""" 
3.3 关键字参数----关键字参数是通过指定参数名来传递的参数。调用函数时，可以根据参数名来传递实参，而不必遵循形参的顺序。 ----注意:关键字参数必须放在位置参数的后面
def 函数名(形参1,形参2,...): 函数体 
函数调用 
函数名(形参2=实参2,实参1=实参1,...) 
""" 
def demo(x,y): print(x+y) 
demo(y=1,x=23) 
""" 
3.4 关键参数与默认参数同时存在时候的使用用法 
""" 
#用法1 
def demo(x,y,z=0,w=0): print(x+y+z+w) 
demo(12,23,w=23) 
""" 
3.5 可变参数----可变参数允许函数接受不定数量的参数 在函数定义中，可以使用特殊符号来表示可变数量的参数， 如 *args 用于接收任意数量的位置参数， **kwargs用于接收任意数量的关键字参数。 """ def demo(name, *data): print(data) 
#最后打印出来的值是一个元组的类型 demo("dwgcqhv",2,33,2,4,34,3,4,5,45) 
#注意传值的字典中各个元素的大小得要与函数的传参保持一致 
#(1)在函数传值的时候使用 
def print_info(name,age): print(name,age) data = {"name":"gsydihcghda", "age":10} print_info(**data) 
#(2)在函数声明的时候使用 
def print_info(name,**kawgs): str1 = kawgs.get("str1") str2 = kawgs.get("str2") print(name) print(str1) print(str2) 
print_info("dhfcjhc",str1 = "qefqefe",str2 = "qefqefe")关于一些加*号的补充语法#=================================== 
# 补充语法 
#（1 关于变量的加*号的序列化接收 
x, y, *z = [1,23,5,56,12,324,4,5] 
i, j, *k = (1,23,5,56,12,324,4,5) 
print(i, j, k) 
print(x, y, z) 
# (2) 多个字符的累计打印 
print("=" * 20) 
# (3) 乘法的作用 
print(2*12) 
# (4) 次方 
print(2**3) 
# (5) 传参 
def foo(x,y): print(x,y) 
l = [1,2] 
foo(*l) 
q = {"name":"yuan","age":12} 
foo(**q) 
#====================================

• 函数的作用域

作用域是指在程序中定义变量或函数时，这些变量或函数可被访问的范围。在不同的作用域中，变量和函数的可见性和访问性是不同的。

当访问一个变量时，Python 会按照 LEGB的顺序进行查找，直到找到第一个匹配的变量，然后停止查找。如果在所有作用域中都找不到变量的定义，就会引发 NameError。

L(Local):局部作用域。包括函数内部定义的变量和参数。在函数内部最先进行变量查找。

E(Enclosing):嵌套函数的父函数的作用域。如果在当前函数内部找不到变量，就会向上一层嵌套的函数中查找。

G(Global):全局作用域。在模块层次定义的变量，对于整个块都是可见的。

B(Built-in):内置作用域。包括 Python 的内置函数和异常。

x = 10 #全局作用域 
def demo(): x = 100 #外部函数作用域 def in_demo(x): x = 30 #内部函数作用域 print(x) # 在内部函数中访问变量 in_demo(x) 
print(x) #在全局作用域中访问变量  # 函数作用域的两个关键字 global 与 nonlocal# (1) global 的使用方法 
y = 100 
def demo1(): global y #将一个局部域的变量变为全局域变量 y = 200 print(y) 
demo1() 
print(y) # (2) nonlocal的使用方法 
def demo1(): y = 200 print(y) def demo_in(): nonlocal y #将函数内嵌套的函数中的局部变量可以影响上一层的局部变量 y = 300 demo_in() print(y) 
demo1() 
print(y)

• 函数的返回值

函数的返回值是指函数执行完毕后，通过 return 语句返回给调用者的结果，使用 return 语句可以将一个值或对象作为函数的返回值返回。这个返回值可以是任何有效的Python对象，例如数字、字符串、列表、字典等。函数执行到 return 语句时，会立即结束函数的执行，并将指定的返回值传递给调用者。

如果函内没有return，默认返回None，代表没有什么结果返回

#返回一个值 
def demo(x,y): return x+y 
print(demo(2,3)) 
#返回多个值 
def demo(): name = "fdjgwfdhjw" age = 56 return name, age #默认会组成一个元组的类型 
print(demo())

• 匿名函数

#匿名函数 ----只能使用一次 
ret = (lambda x,y: x+y)(100,300) 
print(ret)

• 常用的内置函数