Day18智能体测开python

集合

# 集合 ''' 1)set() {} 2）集合中的元素是单个元素，不是键值对 3）无序的，不能重复的 4）可变的，增删改 5）集合中的元素类型是不可变的 ''' s = set() print(type(s))#<class 'set'> s = {3,44,21,5,25,67,7,78,77} # s = {3,4,4,4,6,7,2,1,55,77,[4,5,6,7]} # 子列表不能作为集合的元素 print(s) # 增 s.add(66) print(s) # 删除 # 根据元素本身去删除 s.remove(7) print(s) v = s.pop() # 随机删除一个元素 print(v) print(s) # s.clear() # 获取集合的长度 print(len(s)) # 遍历 for i in s: print(i) # 对列表中的元素进行去重 li = [5,4,3,21,3,5,6,55,77,8,88,2,2,3,4,6] # 方式1 优点：不改变列表的元素顺序 缺点：逻辑复杂 # 创建一个空的新列表 lnew=[] for i in li: # 往空列表中存储数据 if i not in lnew: # 判断新列表中是否含有该元素 lnew.append(i) print(lnew) # 方式2 缺点：源列表的顺序改变了 优点：逻辑简单 # 将列表转变成集合 s2 = set(li) # 集合转变成列表 l = list(s2) print(l)

函数

# 函数 ''' 目的:提高代码的复用率，可以重复执行一些有规律的代码 函数的定义格式： def 函数名称(参数名1,参数名2...): 函数体：有规律的代码 函数的调用：函数名(参数值1,参数值2...) 1）函数的参数可以是0-多 2）函数体执行：必须是调用函数才会执行 3）函数体可以加return关键词 1)return后面可以跟一个数据 2)return后面可以不加任何的数据，代表返回None,可以省略 3)return代表函数执行结束了 4）python提供了一些内置的函数print() int() list() set ord() min() max() 5）函数的调用，必须写在函数的定义下面 ''' print(min(2,3,4,52,22,11,-9)) # 自定义函数 1-100的和 def print_sum(): sum =0 for i in range(1,101): sum += i print(sum) # return None # return # 调用函数 print_sum() # n-m的和 def print_sum1(n,m): sum =0 for i in range(n,m+1): sum += i print(sum) # 调用函数时，给n和m赋值 定义函数时参数和调用函数时的参数，顺序，类型，个数都一致 print_sum1(3,40) print_sum1(2,39) def print_sum2(n1:int,m1:int):# 规定了参数的数据类型，但是调用时，参数类型只作为参考，不能限定，因为python是弱类型的语言 """ 计算某个范围内地函数的和 :param n: 开始值 :param m: 结束值 :return: """ sum = 0 for i in range(n1, m1 + 1): sum += i print(sum) r = print_sum2(3,30) print(r) #None # 返回函数中的值，目的可以在函数外使用该值 def get_sum(): print("---------------") sum = 0 for i in range(1, 101): sum += i return sum # 调用函数并且获取返回值 s = get_sum() sum = get_sum() print(f"使用和去进一步计算{s+1}") def abc(): for i in range(1,100): if i == 9: # break return print(i,"-----------") abc() ''' 函数体可以使用pass替代 参数：在函数定义时的参数叫形参，函数调用时的参数叫实参（实际参数） 1）位置参数：形参和实参的顺序、类型、个数必须相同 2）默认参数：参数如果没有提供实参，参数按默认值走 3）可变参数：实参的值，可以是0-多个 4）关键字参数：字典参数 ''' def abc(n,m,o): pass # 空语句 # if 6>7: # pass # else: # pass abc(4,5,6) # 有默认值的参数 def print_info(name,age,sex='男',height=178.98):# 如果参数有默认值，必须设置在参数列表的后面 print(f"name={name},age={age},sex={sex},height={height}") print_info('tom',23,'女') print_info('tom',23) print_info('tom',23,height=167.98) # 如果空掉其中一个参数，可以使用参数名去赋值 print_info(name = 'tom',age=23,height=167.98,sex='女') # 如果空掉其中一个参数，可以使用参数名去赋值 print_info(age=23,name = 'tom',height=167.98,sex='女') #如果实参的传递，加上参数名，可以打乱顺序 a = ('lucy',7,'女',123.98) print_info(*a) # 解包，通过*对列表中的元素进行解包，逐个将列表的元素传递给参数 b = [12,'lily',156.78] age,name,height = b # 解包 print_info(name,age,height=height) # *参数名，代表是一个可变参数,传递的参数可以是0-多个，并且在函数体中打包成一个元组处理 # **参数名，代表是一个可变关键字参数,传递的参数可以是0-多个，并且在函数体中打包成一个字典处理 ''' 1）*参数名一般定义为 *args **参数名一般定义为**keys 2）python提供了一些可变参数的函数print() min() max() 3）参数为*args,**keys可以代表通配所有的参数了 4）考点：* 和**的区别 *args和**keys的区别 ''' def get(n,*args,**keys): print(f"f={n}，m={args},k={keys}") get(45) get(45,8) get(45,8,9) get(45,8,9,'tom',name='tom') print(min('tom','lucy','lily')) def get1(*args,**keys): print(f"m={args},k={keys}") get1() get1(3) get1(3,4,5) get1(3,4,5,"kafa",name='t',age=50)

变量

# 变量 ''' 根据变量的作用域范围：全局变量和局部变量 全局变量：直接定义在文件中的变量 局部变量：定义在函数中或分支循环中的变量 ''' a= 99 c = 22 def abc(n,m):# 参数也是局部变量 # 定义局部变量 b = 8 a = 77 # 和全局变量同名的局部变量 print(n,m) print(f'a={a},b={b},c={c}') abc(4,5) print(a) # 在函数中可以定义全局变量，使用global关键词定义 def get(): global d # 声明全局变量 d = 89 f = 'tom' # global e = 8 print(f) get() # 调用函数，执行设置全局变量的代码 print(d)

lambda表达式

# lambda ''' 一些简单的函数，可以通过lambda表达式进行简化，定义为一个没有函数名的函数 lambda：没有函数名的函数 ''' def power(x): return x**2 b = lambda x:x**2 # b变量代表一个函数 b1 = lambda a:a**2 # b变量代表一个函数 print(b(8)) # 函数体中有分支if else def abs(x): if x>=0: return x else: return -x c = lambda i:i if i>=0 else -i print(c(9)) print(c(-9)) def add(x,y=9): return x+y d = lambda x,y:x+y d1 = lambda x,y=9:x+y print(d(4,51)) print(d1(4,56)) print(d1(4)) print(type(d1)) #<class 'function'>

课后作业

A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} # 获取两个集合的交集， def Intersection(A,B): C = set() for i in A: if i in C: continue for j in B: if i == j: C.add(i) print("两个集合的交集为：",C) # 并集 def Union(A,B): for k in B: if k not in A: A.add(k) print("两个集合的并集为：",A) # 获取A中有，但是B中没有的 def ishave(A,B): D = set() for i in A: if i not in B: D.add(i) print("A中有，但是B中没有：",D) # 检查A是否是B的子集 def issubset(A,B): s_subset = True # 遍历A每一个元素，只要有一个不在B，就不是子集 E = True for num in A: if num not in B: E = False break if E: print("A 是 B 的子集") else: print("A 不是 B 的子集") # 每个小题定义一个函数并且调用 Intersection(A,B) Union(A,B) ishave(A,B) issubset(A,B) # 从列表中找出只出现一次的元素 不通过count()方法查找 l=[1,2,4,5,9,8,7,1,2,3,5,4,6] def one(l): l_new=[] for i in l: count = 0 for j in l: if i == j: count += 1 if count == 1: l_new.append(i) print(l_new) one(l)

Python 四大容器总结

1. 列表 list []

1. 特性：有序、元素可重复、可变，支持下标索引、切片
2. 操作：增 append / 删 pop / 改下标赋值
3. 缺点：去重麻烦，判断元素是否存在效率低
4. 适用：动态有序数组、需要频繁修改的数据

2. 元组 tuple ()

1. 特性：有序、元素可重复、不可变，支持索引切片
2. 操作：创建后不能增删改，仅可读
3. 优点：内存占用小、可哈希，能作为字典 key
4. 适用：固定不变数据、函数多返回值

3. 字典 dict {key:value}

1. 特性：3.7 + 插入有序，键唯一、值可重复，可变
2. 规则：key 必须不可变类型（数字 / 字符串 / 元组），列表集合不能当键
3. 操作：通过键存取、新增键值、修改 value
4. 适用：键值映射数据，存储对象信息

4. 集合 set {}

1. 特性：无序、自动去重、可变，无下标不能索引
2. 独有运算：交集、并集、差集、子集判断
3. 操作：add 添加、remove 删除
4. 适用：列表去重、对比两组数据关系、成员快速判断

*args和**keys的区别

*参数名，代表是一个可变参数,传递的参数可以是0-多个，并且在函数体中打包成一个元组处理
**参数名，代表是一个可变关键字参数,传递的参数可以是0-多个，并且在函数体中打包成一个字典处理

对列表中的元素进行去重

li = [5,4,3,21,3,5,6,55,77,8,88,2,2,3,4,6] # 方式1 优点：不改变列表的元素顺序 缺点：逻辑复杂 # 创建一个空的新列表 lnew=[] for i in li: # 往空列表中存储数据 if i not in lnew: # 判断新列表中是否含有该元素 lnew.append(i) print(lnew) # 方式2 缺点：源列表的顺序改变了 优点：逻辑简单 # 将列表转变成集合 s2 = set(li) # 集合转变成列表 l = list(s2) print(l)