本文深入探讨了Python中的集合操作，包括添加元素、删除元素、合并及运算符使用。此外，介绍了函数的参数、返回值、注释、调试技巧以及全局和局部变量。还涉及了默认参数、可变参数、可变类型和不可变类型的概念。最后，讨论了递归函数、匿名函数、排序方法以及内置函数如filter、map、reduce的使用。
python学习No5
集合
集合是一个不重复的无序数据集合，可以使用{}或者set表示
{}有两种意思：字典、集合
{}如果里面是键值对就是字典，如果是单个值，就是一个集合
person={'name':'zhangsan','age':18}#字典
x={'hello',10,'good'}#集合
#如果有重复的数据，会自动去除
name={'zhangsan','lisi','wangu','zhangsan'}
print(name)#{'zhangsan', 'wangu', 'lisi'}
集合的部分操作
name={'zhangsan','lisi','wangu','zhangsan'}
print(name)
#增加元素
name.add('oo')
print(name)
#删除
name.pop()#随机删除
print(name)
#指定删除
name.remove('lisi')
print(name)
#合并生成新集合
print(name.union('你好', 'aa'))
print(name)
#将B拼A中,B是任意可迭代对象
#A.update(B)
name.update({'好耶','豪尔'})
print(name)
#无查询方法，因为集合无序
集合的运算符
sing={'a','b','c','d','e','f','z','h'}
dance={'a','c','d','g','q','t','p','h'}
rap={'a','s','m','b','f','e','j','l'}
#set支持很多算数运算符
#没有+操作print(sing+dance)
print(sing - dance)#差集
print(sing & dance)#交集
print(sing | dance)#并集
print(sing ^ dance)#差集的并集
转换的方法
#内置类 list tuple set
nums=[3,6,2,7,8,9]
x=tuple(nums)#使用tuple内酯类转换为元组
print(x)
y=set(nums)#转换位集合
print(y)
z=list({'name':'aaa','age':18})
print(z)
#
# #python有一个强大的内置函数eval，可以执行字符串中的代码
# a = 'input(“请输入您的用户名”)'
# eval(a)
# b='1+1'
# print(eval(b))
import json
#JSON的使用，将列表，元组，字典转换为字符串
person={'name':'zhangsan','age':18}
#字典如果要传给前端------》'{"name":"zhangsan","age":18,"gender":"man"}'
m=json.dumps(person)
print(m)#是字符串了
n='{"name": "zhangsan", "age": 18}'
p=eval(n)
print(p)
s=json.loads(n)#可以将josn字符串转换为py中的数据
print(type(p))
print(s)
列表集合元组字典等的区别
- *表示重复多次，而字典集合数据无法重复
- 都可用for in遍历
- 带下标的遍历
nums=[109,34,59,12,3]
for i,e in enumerate(nums):
print(‘第%d个数据是%d’%(i,e))
函数
函数是准备好的代码，解决规定的问题，提高可读性和维护性。
把多行代码封装成一个整体，在python中使用关键字def来声明一个函数。格式如下：
def 函数名（参数）：
函数要执行的操作
#函数定义好之后不会主动执行，要调用
def tell_story():
print('从前有座山')
print('山上有座庙')
print('庙里有个老和尚给小和尚讲故事')
print('故事内容是')
age=int(input('请输入孩子的年龄'))
if age>5:
tell_story()
else:
for i in range(5):
tell_story()
函数的参数
def tell_story(person):
print('从前有座山')
print('山上有座庙')
print('庙里有个'+person+'给'+'小和尚讲故事')
print('故事内容是')
tell_story('老和尚')
给pycharm换了一个背景，看着鹿鸣学习觉得好快乐啊！！！
py中不限制参数类型
def add(a,b):
c=a+b
return c
x=add(1,2)
print(x)
y=add('hello','world')
print(y)
#可以进行参数限定，但是依旧可以执行，只是会有提示，不报错
def add(a：int,b：int):
c=a+b
return c
y=add('hello','world')
print(y)
函数的返回值
返回值是函数执行的结果，并不是所有函数都必须有返回值
def add(a,b):
c=a+b
return c
result=add(1,2)
print(result**4)
如果一个函数没有返回值，它的返回值就是None
x=print('Hello')
print(x)
函数的注释
def add(a,b):
"""
相加函数
:param a:第一个人数字
:param b:第二个数字
:return:两个数字相加
"""
return a+b
#内置函数查看函数内容
help(add)
函数中常用的调试键
全局变量和局部变量
只有函数分割作用域，只要变量不在一个函数中，就是全局变量
a=100#a是全局变量
def text():
x='hello'
print(x)
print(a)
a=10#此刻的a是局部变量，不是把a改变了
text()
#print(x) x是局部变量，不能再函数体外使用
a=100
word='hello'
def text():
x='hello'
print(x)
a = 10
print(a)
#此刻的a是局部变量，不是把a改变了
#函数内部改变全局变量,使用global对变量进行声明，可以通过函数修改全局变量的值
global word
word = 'ok'
#内置函数globals()可以查看全局变量 locals()查看局部变量
print('locals={},globals={}'.format(locals(),globals()))
text()
#print(x) x是局部变量，不能再函数体外使用
print('函数外部a={}'.format(a))
print('函数外部word={}'.format(word))
函数的多个返回值
一般情况下，函数有一个返回值
但有特殊情况（finally语句），会执行多个return
# def test(a,b):
# x=a+b
# y=a-b
# return x#函数中遇到第一个return就默认结束
# return y
def test(a,b):
x=a+b
y=a-b
return [x,y]
#或者用字典或者元组
result=test(3,2)
print('加法是{}，减法是{}'.format(result[0],result[1]))
def text(a,b):
x=a*b
y=a/b
return x,y#元组返回
cheng,chu=text(15,3)
print('乘法是{}，除法是{}'.format(cheng,chu))
默认参数的使用
缺省参数：有些函数的参数，如果传递了参数，就使用传递的，如果没有传递参数，就使用默认值。比如print()函数中end或者sep就是一个缺省函数。
#defsay_hello(city='河北',name,age)缺省参数要放在最后面
def say_hello(name,age,city='河北'):
print('大家好，我是{},我今年{}岁了，我来自{}'.format(name,age,city))
say_hello('jacj',19)#没有传递参数，用默认值
say_hello('san',12,'北京')#有参数，就使用传递的参数
#可以传递单个参数，也可以传递关键字参数，若两者同时存在
#关键字参数必定再位置参数后面所以jerry不能再最后面
say_hello('jerry',age=24,city='天津')
可变参数的使用
前面提到返回多个值时我们使用可迭代对象列表或元组等进行返回，类比一下，于是考虑用列表元组等来传多个参数值
def add(a,b):
return a+b
def add1(m):
x=0
for n in m:
x+=n
return x
nums=[1,2,3,4,5]
print(add1(nums))
想法二：python中的多值传参
add(a,b,*args)至少需要两个参数
add(*args)可以没有参数
#*args表示可变参数
#kwargs表示可变的关键字参数
def add(a,b,*args,mul=1,**kwargs) :
print('a={},b={}'.format(a,b))
print('args={}'.format(args))#多出来的参数保存到args中
print('kwarg={}'.format(kwargs))
add(9,5,4,3,2,mul=2,x=0,y=4)
可变类型和不可变类型
列表数据是可变的，函数执行的过程中能够改变值。
def test(a):
a=100
def demo(nums):
nums[0]=10
x=1
test(x)
print(x)
y=[3,5,6,8,2]
demo(y)
print(y)
函数的注意事项
- 不允许出现同名函数，即便参数不同也不行
- 函数名称尽量避免是python中的标识符
递归函数
递归就是函数内部自己调用自己
举例：递归求1+2+3+4+…n
def get_sum(n):
if n==1:
return 1
return get_sum(n-1)+n
print(get_sum(6))
斐波那契数列递归：
print(get_sum(6))
def fun(n):
if n==1 or n==2:
return 1
return fun(n-1)+fun(n-2)
print(fun(5))
匿名函数
格式：
lambda 传参：返回值
def add(a,b):
return a+b
print("0x%x"%id(add))
x=add(4,5)#函数名(实参) 作用是调用函数，获取函数执行结果，赋值给x
print(x)
fn=add#给add取别名,地址相同都是函数地址
print("0x%x"%id(fn))
#除了使用def关键字定义函数外，我们还可以使用lambda表达式定义一个函数
lambda a,b:a+b#匿名函数表达式，用来表达一个杉树，调用次数少，基本调用一次
#调用匿名函数的两种方式：
#1.定义一个名字(使用少)
mul=lambda a,b:a+b
#2.把这个函数当做参数传递给另一个函数使用(使用场景多)
def calc(a,b,fn):
c= fn(a,b)
return c
def add(x,y):
return x+y
def minus(x,y):
return x-y
#回调函数
x=calc(1,2,add)#不能加add()，传入fn，相当于别名使用
print(x)
x2=calc(9,6,minus)
print(x2)
#lambda的使用
def calc(a,b,fn):
c= fn(a,b)
return c
x3=calc(1,2,lambda x,y,:x+y)
x4=calc(13,2,lambda x,y:x-y)
x5=calc(2,7,lambda x,y:x*y)
print(x3,x4,x5)
sort方法的具体使用
student=[{'name':'张三','age':18,'tel':'121'},
{'name':'类似','age':17,'tel':'121'},
{'name':'俺试','age':14,'tel':'121'},
{'name':'为u','age':13,'tel':'121'},
{'name':'宿舍','age':16,'tel':'121'},
{'name':'谷歌','age':18,'tel':'121'}
]
#student.sort()报错
#TypeError: '<' not supported between instances of 'dict' and 'dict'
#字典和字典之间不能使用比较运算
#foo() takes 0 positional arguments but 1 was given
#sort内部实现时候，调用了foo方法，并传入了一个参数
#foo这个函数需要0个位置参数，但是调用的时候传入了一个参数,参数就是列表中的一个个元素
def foo(ele):
#print("ele:{}".format(ele))
return ele['age']#通过返回值告诉sort，按照这个属性进行排序
#所以sort需要传入key 指定比较规则，key参数类型是函数
student.sort(key=foo)#报错
print(student)
filter、map、reduce
filter过滤，在python2中是内置函数，py3中是内置类，是对可迭代对象过滤，得到一个filter类型的对象，也是可迭代对象。filter可以给定两个参数，第一个是函数，第二个是可迭代对象。
age=[12,34,56,78,34,55,66]
x=filter(lambda x: x > 44, age)
print(x)
for a in x:
print(a)
map：让每一个数据执行函数里的操作
age=[12,34,56,78,34,55,66]
m=map(lambda ele :ele+2,age)
print(m)
print(list(m))
reduce:以前是一个内置函数，现在改到了模块中
内置函数和内置类都在builtins.py文件里
from functools import reduce
scores=[100,22,33,44,55]
print(reduce(lambda ele,elel:ele+elel,scores))
#第一次调用 ele=100 elel=22
#第二次调用 ele=122 elel=33
#第三次调用 ele=155 elel=44
#...
from functools import reduce
#如果是字典，要求算出年龄和
student=[{'name':'张三','age':18,'tel':'121'},
{'name':'类似','age':17,'tel':'121'},
{'name':'俺试','age':14,'tel':'121'},
{'name':'为u','age':13,'tel':'121'},
{'name':'宿舍','age':16,'tel':'121'},
{'name':'谷歌','age':18,'tel':'121'}
]
def bar(x,y):
return x+y['age']
#0是给x赋初值，第一次x=0，y=18，后面按照reduce基本做
print(reduce(bar,student,0))
一些内置函数
#求绝对值
print(abs(-10))
#将可迭代对象中的值转为布尔值，如果所有为True就输出True
print(all(['hello', 'good', 'yes']))
print(all(['hello',0]))
#只要有一个true就true
print(any(['hello',0]))
#转换相关
#bin：将数字转换为二进制
#chr：将字符编码转换成为对应的字符 char(a)=97
#ord：将字符转换成为对应的编码 ord('a')=p7
#dir列出所有能支持的方法
num=[1,2,3]
print(dir(num))
#divmod求两个数的商和余数
print(divmod(15,2))
#exit()结束程序
#isunstance判断一个类是否由另一个类创建出来
#issubclass:判断一个类是否是另一个类的子类
#iter:获取可迭代对象的迭代器
#next:for...in 循环本质就是调用迭代器的next方法
高阶函数
1.一个函数作为另一个函数的返回值
def foo():
print('我是foo，我被调用了')
return 'foo'
def bar():
print('我是bar，我被调用了')
return foo
x=bar()#x就是foo函数
print('x的值是{}'.format(x))
#在此之前foo函数没有被调用，x相当于是foo()的别名
print('---------')
x()
print('---------')
y=bar()()
print(y)
2.一个函数作为另一个函数的参数，lambda表达式的使用
sort filter map reduce
3.函数内部定义一个函数(函数嵌套)
注意：a=bar()是调用bar函数
a=bar是指a是bar的别名
def outer():
m=100
def inner():#inner函数是定义在outer函数内部，外部不可用
n=90
print('我是inner函数')
print('我是outer函数')
return inner#加上才会调用inner
outer()#不会调用inner
闭包
闭包是由函数及其相关引用环境组合而成的实体（闭包=函数快+引用环境）如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包
def outer():
m=100
def inner():
n=m+1
return inner
def outer():
x=100
def inner():
#在内部函数如何修改外部函数的局部变量
nonlocal x
y=x+1
print('inner里的y=',y)
x=20#不是修改外部x的变量，二十inner函数内部又创建了一个新的变量
#加上nonlocal后才是外部变量
return inner
outer()()
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
