python学习No5

集合
- 集合的部分操作
- 集合的运算符
- 转换的方法
列表集合元组字典等的区别
函数
- 函数的参数
- 函数的返回值
- 函数的注释
- 函数中常用的调试键
- 全局变量和局部变量
- 函数的多个返回值
- 默认参数的使用
- 可变参数的使用
- 可变类型和不可变类型
- 函数的注意事项
- 递归函数
- 匿名函数
- sort方法的具体使用
- filter、map、reduce
一些内置函数
- 高阶函数
- 闭包

集合

集合是一个不重复的无序数据集合，可以使用{}或者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+breturn c
x=add(1,2)
print(x)
y=add('hello','world')
print(y)
#可以进行参数限定，但是依旧可以执行，只是会有提示，不报错
def add(a：int,b：int):c=a+breturn c
y=add('hello','world')
print(y)

函数的返回值

返回值是函数执行的结果，并不是所有函数都必须有返回值

def add(a,b):c=a+breturn cresult=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 = 10print(a)#此刻的a是局部变量，不是把a改变了#函数内部改变全局变量,使用global对变量进行声明，可以通过函数修改全局变量的值global wordword = '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+by=a-breturn [x,y]#或者用字典或者元组
result=test(3,2)
print('加法是{}，减法是{}'.format(result[0],result[1]))
def text(a,b):x=a*by=a/breturn 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+bdef add1(m):x=0for n in m:x+=nreturn 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]=10x=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 1return get_sum(n-1)+n
print(get_sum(6))

斐波那契数列递归：

print(get_sum(6))
def fun(n):if n==1 or n==2:return 1return 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=100def inner():#inner函数是定义在outer函数内部，外部不可用n=90print('我是inner函数')print('我是outer函数')return inner#加上才会调用inner
outer()#不会调用inner

闭包

闭包是由函数及其相关引用环境组合而成的实体（闭包=函数快+引用环境）如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包

def outer():m=100def inner():n=m+1return inner

def outer():x=100def inner():#在内部函数如何修改外部函数的局部变量nonlocal xy=x+1print('inner里的y=',y)x=20#不是修改外部x的变量，二十inner函数内部又创建了一个新的变量#加上nonlocal后才是外部变量return innerouter()()