Python每日笔记06
本次内容：集合+函数+推导式+引入文件
目录
>> Python每日笔记—Day01 <<
>> Python每日笔记—Day02 <<
>> Python每日笔记—Day03 <<
>> Python每日笔记—Day04 <<
>> Python每日笔记—Day05 <<
>> Python每日笔记—Day06 <<
>> Python每日笔记—Day07 <<
>> Python每日笔记—Day08 <<
>> Python每日笔记—Day09 <<
这两天讲的东西比较多，由于时间关系被拆分了，所以在保证了足够量的情况下，尽量把每一块内容整合到一起，方便学习。
集合Set
- 集合(set)是一个无序的不重复的存储元素的数据结构
集合和字典一样也用{}表示，那么第一个问题：如何创建一个空集合？set()，不能使用{}
set1 = set() # 创建一个空集合
''' 集合性质：无序性，不重复性（去重性）'''
print(type(set1))
set2 = {
'apple', 'orange', 'banana', 'apple'}
print(set2) # {'banana', 'apple', 'orange'}
print('apple' in set2) # 成员运算符仍可以使用
- 差集、交集、并集、异或运算符
注：集合是无序的，所以每次随机打印顺序
'''
A－B＝{x|x∈A，且x ￠B}
差集运算:A集合中有的元素，但不包含于B集合中共有的元素
'''
set1 = {
'a', 'b', 'c', 'd', 'e'}
set2 = {
'd', 'e', 'f', 'g'}
print(set1 - set2) # {'c', 'b', 'a'}
'''
A|B = A∪B={x|x∈A,或x∈B}
并集运算:AB集合中所有的元素
'''
print(set1 | set2) # {'g', 'd', 'f', 'b', 'c', 'a', 'e'}
'''
A&B = A∩B={x|x∈A,且x∈B}
交集运算:AB集合中共有的元素
'''
print(set1 & set2) # {'d', 'e'}
'''
A^B 异或运算:不包含两个集合的元素
'''
print(set1 ^ set2) # {'g', 'f', 'b', 'c', 'a'}
- 集合的增加和删除元素
'''1、增加：add函数和update函数'''
s1 = {
1, 2, 3}
s2 = {
7, 8}
'''集合添加元素：add() 参数为一个元素'''
s1.add(100) # {1, 2, 3, 100}
print(s1)
s1.add('A') # 可以添加字符串但是有警告
print(s1) # {'A', 1, 2, 3, 100}
# s1.add([1, 2]) # 不可以添加一个list对象会报错
# s1.add(s2) # 不可以添加一个set对象会报错
'''update() 参数必须为一个序列！'''
s1.update(s2)
print(s1) # {1, 2, 3, 100, 7, 8, 'A'}
s1.update([9, 10])
'''update这里9和10相当于两个单独的元素，add添加的是一个整体'''
print(s1) # {1, 2, 3, 100, 'A', 7, 8, 9, 10}
'''2、删除操作
pop():随机删除序列的第一个元素
remove(element):删除set集合中指定的element元素，如果不存在则报错
discard(element):删除set集合中指定的element元素，如果不存在不会报错
'''
s1 = {
'a', 'b', 'c'}
print(s1.pop()) # 随机删除一个
print(s1)
s1 = {
'a', 'b', 'c'}
s1.remove('a')
print(s1) # {'c', 'b'}
s1.discard('f') # 删除不存在的元素不会报错
4、常用内置函数
'''
add()为集合添加元素
update()为集合添加元素
clear()移除集合中所有的元素
copy()复制一个集合
difference()返回多个集合的差集
discard()移除元素元素不报错
remove()衣橱元素，不存在会报错
isdisjoint()判断两个集合是否包含相同的元素
union()返回连个集合的并集
'''
集合的内容和列表元组的内容比较相似，差距不大，在这里不再赘述，有兴趣的读者自己进行测试。
函数Function(Python3.X)
——是组织好的，可重复使用的，用来实现单一或者关联功能的代码段
——函数能够提高应用的模块性，模块的重用性，提高模块使用复用率
- 简单定义两个函数
函数体结构如下
'''
如何定义一个函数：
函数的代码块以def关键词开头，后跟随函数名()
def 函数名(参数列表):
逻辑代码块/函数体
'''
def hello():
print("hello world")
hello() # 通过方法名直接调用
def max1(a, b):
print("a=%d" % a, "b=%d" % b)
if a > b:
return a
else:
return b
a = 4
b = 5
num = max1(a, b)
print(num) # 5
'''想要打印一个m行，n列的实心矩形'''
def print_wall(m, n):
for i in range(m):
for j in range(n):
print("-", end=' ')
print()
print_wall(10, 20)
- 小练习——圣诞树
'''
通过方法实现打印一个圣诞树
树层数和树干层数相同，且树干位于中间
*
***
*****
*
*
*
'''
def print_test(m):
for i in range(1, m+1):
for space in range(m - i):
print(' ', end='')
for star in range(2*i-1):
print('*', end='')
print()
for i in range(1, m+1):
for j in range(1, m):
print(' ', end='')
else:
print('*', end='')
print()
print_test(7)
- 函数的参数传递
参数传递：
在python中，类型属于对象，变量是没有类型的。
a = 10
可更改对象与不可更改对象
在python中str、tuple和number是不可更改的对象，而list、dict等是可以修改的对象
不可变类型：变量a = 5之后，在a = 10此时生成一个新的int值对象，然后a变量重新执行该对象
可变类型：a=[1, 2, 3, 4] 再赋值修改a[0] = 5，是修改列表中的一部分内容，列表本身地址没有改变
——：python中的一切都是对象，严格意义上我们不能阐述为值传递还是引用传递
应该表述为传递可变对象或者不可变对象
def change(a):
print(id(a)) # 1983513072
a = 10 # 重新定义了a，a的地址改变，无法把值传回
print(id(a)) # 1983513072
# return a
'''或者可以设置return a，用a接收，可以改变a的值'''
a = 1
print(id(a)) # 1983513360
change(a)
print(a) # 1 这里没有变值，因为a的地址在change()里面改变了
print(id(a)) # 1983513072
'''
通过id函数查看内存地址变化
在函数调用前后，形参和实参，指向的是同一个对象（id地址相同）
在函数内部，修改形参后，形参指向的是不同的id
'''
# 传递可变对象实例
# 可变对象在函数里面修改了参数
def change_list(my_list):
# 修改传入的列表
my_list.append([1, 2, 3, 4]) # 函数内没有改变地址，只是进行了增改内容
print("函数内取值：", my_list)
return
my_list = []
change_list(my_list) # 函数内取值： [[1, 2, 3, 4]]
print("函数外取值：", my_list)
- 函数的参数类型：
—必须参数—
—关键字参数—
—默认参数—
—不定长参数—
—必须参数—（必须以正确的顺序传入函数，调用时的数量必须和声明的时候一样）
''' 必须参数 '''
def print_me(str):
print(str)
return str
print(print_me("dd"))
'''
关键字参数：使用关键字参数运行参数调用时，参数的顺序与声明的时候不一致
因为python解释器能够用参数名匹配参数值
写法：print(print_me(str = "传值"))
'''
def count_area(width, height):
width -= 1
height -= 2
return width*height
count_area(height = 4, width = 5)
'''调用函数的时候，如果没有传递参数
默认参数：在函数的参数列表里，给一个默认值default
'''
def print_info(name ,age = 35):
print(name, age)
print_info(1)
'''
不定长参数：参数个数不固定，参数列表长度不固定
用*修饰的参数名，会以元组的形式进行数据导入，存放所有未命名的变量参数
'''
def print_info(arg1, *var_tuple):
# 不定长三处验证：打印任何传入的参数
print(arg1)
print(var_tuple)
for var in var_tuple:
print(var)
return
print_info(70, 60, 50, 40)
'''
参数前面用两个**修饰，说明该参数会以字典的形式导入
'''
def print_info1(arg1, **var_dict):
"""测试字典类型的不定长参数，要求打印人数传入的参数"""
print("输出")
print(arg1)
print(var_dict)
# 调用当前参数，进行测试
print_info1(1, name = '张三', age = 18) # 1 {'age': 18, 'name': '张三'}
'''测试：如果单独出现*后的参数，必须使用关键字传入，否则会报异常'''
def f(a, b, *, c):
return a+b+c
print(f(1, 4, c = 5)) # 10
- 推导式
首先给出定义：
列表的推导式：用一个表达式来创建一个有规律的列表或者控制一个有规律的列表
'''这里给出几种不同的创建方式，对比学习'''
# 创建一个0-10的列表
list1 = []
# 1、使用while循环
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 2、使用for循环
list1 = []
for i in range(0, 10):
list1.append(i)
i += 1
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 3、使用列表推导式
list1 = [i for i in range(0, 10)]
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 4、带有if的列表推导式（带有条件）
# 创建0-10的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1) # [0, 2, 4, 6, 8]
# 5、多重for循环实现列表推导式
# 创建列表为[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1) # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# 普通方法for循环嵌套的方法
list1 = []
for i in range(1, 3):
for j in range(3):
list1.append((i, j))
j += 1
i += 1
print(list1)
字典的推导式：用一个表达式来创建一个有规律的字典或者控制一个有规律的有规则的字典
'''
字典推导式：
创建一个字典，字典的key是1-5的数字，value是这个key的平方
'''
dict1 = {
i: i**2 for i in range(1, 6)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
'''将两个列表合并为一个字典'''
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, '男']
dict1 = {
list1[i]:list2[i] for i in range(len(list1))}
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男'}
'''通过某一条件获取字典中的目标数据
使用for+if，但是字典比较特殊获取元素需要使用items()方法
'''
counts = {
"apple": 365, "banana": 200, "pear": 20, "orange": 400}
'''你一年吃过的水果超过200的种类有哪些 items()'''
count = {
key: value for key, value in counts.items() if value >= 200}
print(count) # {'banana': 200, 'orange': 400, 'apple': 365}
集合的推导式：用一个表达式来创建一个有规律的集合或者控制一个有规律的有规则的集合
'''集合推导式'''
# 创建一个集合，数据为list1[1, 1, 2]的2次方
list1 = [1, 1, 2]
set1 = (i**2 for i in list1)
print(set1)
- 文件的引入
文件的引入，意思就是调用其他py文件中的函数和变量
使用的关键字是import
下面给出第一个案例：
# 文件名称：support.PY
# 开发工具：PyCharm
def print_function(par):
print("hello", par)
return
sum1 = lambda arg1, arg2: arg1 + arg2
message = "测试是否能够访问模块里的变量"
在文件中导入使用import的关键字，如果调用变量或者函数需要用到.运算符
# 文件名称：test.PY
# 开发工具：PyCharm
from Day05 import support
'''一个模块只会被导入一次，防止导入模块重复执行'''
support.print_function("world") # hello world
num = support.sum1(3, 5)
print(num) # 8
print(support.message) # 测试是否能够访问模块里的变量
如果只想导入文件中的某个函数怎么办呢？
或者文件的名称比较规格化太长了怎么办？
请看如下案例：
# 文件名称：fibo_a.PY
def fib(n):
a, b = 0, 1
while b < n:
print(b, end="")
a, b = b, a + b
print()
def fib2(n):
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a + b
return result
在fibtest文件中引入fibo文件的具体函数，就可以使用其中的函数了，这样不需要使用.来表示了
如果在开发的过程中，使用规格化比较长的名称，这时候可以使用别名as关键字，十分方便
# 文件名称：fibo_test.PY
i = 1
'''导入模块的局部功能和全部功能'''
'''此处只导入了fibo_a中的fib函数和fib2函数'''
from Day05.fibo_a import fib, fib2
fib(5)
fib2(6)
# 设置fibo_a的别名f
from Day05 import fibo_a as f
- 主函数__main__属性：
# 文件名称：name.PY
'''
__name__属性:
一个模块被另一个程序第一次引入的时候，其主程序将运行。
如果想在模块被引入的时候模块中的某一程序块不执行，
我们可以使用__name__属性使该程序仅在该模块自身运行的时候运行
'''
def print1():
print("测试语句1")
def print2():
print("测试语句2")
'''main方法：输入main直接使用快捷键'''
if __name__ == '__main__':
print1()
else:
print2()
- 课后练习——函数改进俄罗斯方块
课堂作业：
俄罗斯方块升级版：
1、创建一个模块module，可以打印七种图形，使用七个有参函数（字符串）
2、创建一个测试文件，在main方法中执行某一测试逻辑
测试逻辑：输入"L"生成L图形，同时可以通过2控制该图形向下移动，6控制该图形向右移动
提示：逻辑问题基本不变，移动需要改变坐标，如何遍历修改坐标是个问题，此外还需要考虑如何调用函数。
下面直接给出答案：
# 文件名称：Model-Tetris.PY
# 开发工具：PyCharm
Tetris = {
'L': [[1, 1], [1, 2], [1, 3], [2, 3]],
'O': [[1, 1], [2, 1], [1, 2], [2, 2]],
'J': [[2, 1], [2, 2], [1, 3], [2, 3]],
'Z': [[1, 1], [2, 1], [2, 2], [3, 2]],
'S': [[1, 1], [1, 2], [2, 2], [2, 3]],
'I': [[1, 1], [1, 2], [1, 3], [1, 4]],
'T': [[1, 1], [2, 1], [2, 2], [3, 1]]}
def L_char(char):
flag = 0
for i in range(0, 7):
for j in range(0, 7):
for li in range(0, len(Tetris[char])): # Tetris['L']
if j == Tetris[char][li][0] and i == Tetris[char][li][1]:
flag = 1
if flag == 1:
print("*", end='')
else:
print(" ", end='')
flag = 0
print()
def move(char, num):
if num == 2:
for li in range(0, len(Tetris[char])):
Tetris[char][li][1] += 1
if num == 4:
for li in range(0, len(Tetris[char])):
Tetris[char][li][0] -= 1
if num == 6:
for li in range(0, len(Tetris[char])):
Tetris[char][li][0] += 1
if num == 8:
for li in range(0, len(Tetris[char])):
Tetris[char][li][1] -= 1
# 文件名称：Test-Tetris.PY
# 开发工具：PyCharm
from Day05 import Model_Tetris
if __name__ == '__main__':
char = input("请输入图形：")
Model_Tetris.L_char(char)
while True:
num = int(input("请输入移动代码2/4/6/8:"))
if num == 8 or num == 2 or num == 4 or num == 6:
Model_Tetris.move(char, num)
Model_Tetris.L_char(char)
else:
break
明天补充lambda表达式的内容，今天的内容就到这里了。
如果这篇文章对你有帮助的话，点个赞呗