学习python_day3
本节内容
1、集合
2、字符编码
3、函数
集合
集合是一个无序的，不重复的数据组合，它的主要作用如下：
- 去重，把一个列表变成集合，就自动去重了
- 关系测试，测试两组数据之前的交集、差集、并集等关系
常用操作
创建集合：集合的函数是set（）
s1 = {1,2,3,5,6,8,"zhangsan","lisi"}
s2 = {2,4,6,8,9,10,"zhangsan","wangwu"}
s = set([3,5,7,9,3,7,10,12])
s4 = set([3,5,7,9])
s3 = set("hello")
增加：
s.add("hello") 会把hello当做一个元素增加到s中
s.add(11)
s.update("e")
s.update(“hello”) 会把hello拆开增加到s中
增加一项 add 或update
s.update(["hello",7,9,10]) 当是个列表时会把hello当做一个元素增加到s中
s.update((11,12,13))
s.update(s1) 把s2中的元素增加到s中
在s中增加多个只能用update
删除：
s.pop() 随机删除，不需要参数
s.remove(5) 指定删除 当指定的元素不存在时会报错，不指定元素也会报错
s.discard("w") 当指定的元素不存在时不会报错，当指定的元素存在时会删除。它不返回任何值
len()
取长度
关系运算
交集：就是两个集合共同的元素
s1&s2 对应的内置方法s1.intersection(s2)
打印的结果：{8, 2, 'zhangsan', 6}
s1.intersection_update(s2) 去完交集后再重新赋值给s1
并集：就是把两个集合合并然后在去重
s1|s2 方法：s1.union(s2) 可以和多个集合操作s1.union(s2).union(s) s1|s2|s
差集：是相对的是某个集合对另一个集合的，是存在一个集合不存在另一个集合的
s1 - s2 方法：s1.difference(s2) s1.difference_update(s2) 相当于 s1 = s1-s2 s1会变成他俩的差集
s2 - s1 方法：s2.difference(s1)
对称差集：去掉两集合的共同的部分，剩下的两集合的所有元素
s1^s2 方法：s1.symmetric_difference(s2)
s1.symmetric_difference_update(s2) 做完对称后重新赋值给s1
子集：
s4<=s 方法：s4.issubset(s)判断s4是不是s的子集，也就是判断s4中的所有元素都有没有在s中
是则打印时返回True ，否则返回False
父集：
s>=s4 方法：s.issuperset(s4) 判断s是不是s4的父集，也就是判断s中的元素是否都包含s4中的元素
是返回True，否则 False
字符编码
字符编码转换关系
首先需明确，计算机各组件之间协同工作，数据传输都是二进制形式，在计算机看来，没有文字，一切都是二进制数，计算机运行主要依靠
cpu：从内存中取出二进制指令执行
内存：从硬盘取出二进制数据提供给cpu运行
硬盘：将人类认识的文字以二进制的形式存放到磁盘上
文件和程序文件都是文件,文件内容的读取或者程序的运行都需要把
- 程序员开发程序，最终写了一堆人为定义的人类认为有意义的文字符号表示，以二进制形式保存到硬盘
- 程序运行，操作系统从硬盘上找到存放程序代码的位置，读取二进制到内存
- python解释器从内存里读二进制，解释执行
如何转换？
首先我们在终端定义一个内存变量：name＝'张三'，那这个内存变量被存放到内存（必然是二进制），所以需要一个编码，就是unicode(内存中使用字符编码固定就是unicode)
但是如果我们写到文件中name＝'张三'保存到硬盘(必然是二进制)，也需要一个编码，这就跟各个国家有关了，假设我们用gbk，那么文件就被以gbk形式保存到硬盘上了。
程序要运行：硬盘二进制（gbk）－－－> 内存二进制（unicode）
就是说，所有程序，最终都要加载到内存，程序保存到硬盘不同的国家用不同的编码格式，但是到内存中我们为了兼容万国（计算机可以运行任何国家的程序原因在于此），统一 且固定使用unicode，这就是为何内存固定用unicode的原因，你可能会说兼容万国我可以用utf－8啊，可以，完全可以正常工作，之所以不用肯定是unicode比utf－8更高效 （uicode固定用2个字节编码，utf－8则需要计算），但是unicode更浪费空间，没错，这就是用空间换时间的一种做法，而存放到硬盘，或者网络传输，都需要把unicode转成utf－8，因为数据的传输，追求的是稳定，高效，数据量越小数据传输就越靠谱，于是都转成utf－8格式的，而不是unicode。
总结：
其实无论是word也好pycharm也好，python解释器也好，我们都可当她们是处理文件的软件
注意：
python2.7解释器默认编码为ascii
python3.5解释器默认编码为utf-8
不管是python解释器也好还是其他与文本相关的软件也好，它们只能指定存取文件到硬盘的字符编码，而内存中固定使用uniccode
test.py文件的头#-*-coding:utf-8-*-就是在修改python解释器的编码
流程：
- 从硬盘读区test.py的二进制bytes类型数据加载到内存，此刻python解释器就是一个类word软件啊，python解释器用自己的编码，将文件的二进制解码成unicode放到内存中
- python解释器从内存中读取unicode代码解释执行，执行时的代码中函数指定的编码与python解释器再无半点关系
函数
函数是什么?
函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做 subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
语法定义：
def sayHi():
print("Hello I'm jack")
sayHi()
带参数的：
def sayHi(name):
print("Hello I'm %s"%name)
sayHi("jack")
sayHi("rain")
def sayHi(name,age):
print("Hello I'm %s"%name) 里面使不使用不管 只要函数要求几个参数你按要求给几个就行
sayHi("jack",22)
实参和形参：
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
默认参数 位置参数 关键参数
默认参数必须放在位置参数后面，如果不指定默认就是CN对形参而言
sayHi(30,name="jack")正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。
从实参角度给形参传递参数：
1. 按位置传递
2.按关键字的方式
3.针对同一个形参，我们要么按位置要么按关键字为形参传值
4，按位置传递参数，关键字必须放在位置后面。（当需要给多个形参传递值时，当其中一个位置出现关键字时其后面的实参也都必须是关键字）
从形参的角度定义参数
1.位置参数（按位置定义，必传值参数）
2.默认参数 定义在位置参数后面
3.非固定参数 *args **kwargs 定义在默认参数后面，如没有默认函数则定义在位置参数后面
4. l=["a","b"]
def foo(x,y,*args):
print(x,y,*args)
foo(1,2,*l)等同于foo(1,2,"a","b") *l就是把l中的元素按位置的方式一个一个的传递给*args然后变成元组
l = [1,2,3]
def foo(x,y,z):
print(x,y,z)
foo(*l)---->foo(1,2,3)
按关键字的方式
def fool(**kwargs):
print(kwargs)
fool(x=1,y=2,z=3)
f = {"name":"alex","age":22}
def fool(**kwargs):
print(kwargs)
fool(**f)---->fool(name=alex,age=22)---->fool(**{"name":"alex","age":22})
非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
|
1
2
3
4
5
6
7
8
9
10
|
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式 print(name,age,args)stu_register("Alex",22)#输出#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空stu_register("Jack",32,"CN","Python")#输出# Jack 32 ('CN', 'Python') |
还可以有一个**kwargs
|
1
2
3
4
5
6
7
8
9
10
|
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式 print(name,age,args,kwargs)stu_register("Alex",22)#输出#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")#输出# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'} |
局部变量
|
1
2
3
4
5
6
7
8
9
10
11
|
name = "Alex Li"def change_name(name): print("before change:",name) name = "金角大王,一个有Tesla的男人" print("after change", name)change_name(name)print("在外面看看name改了么?",name) |
输出
|
1
2
3
|
before change: Alex Liafter change 金角大王,一个有Tesla的男人在外面看看name改了么? Alex Li |
全局与局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
局部变量默认不能修改全局变量，只能引用
n = "in the out"
def change():
print(n)
change()
函数内部想修改全局变量得需要事先声明 global,建议不要用
n = "in the out"
def change():
global n
n = "in the in"
print(n)
chang()
print(n)
当传递的参数是列表时：
names = ["alex","jack"]
def change(names):
names.append("rain")
names[0]= "tom"
change(names)
print(names)
可以看到names列表被改变了，是因为给函数change()传递的是names列表的内存地址不能修改，但是列表内的元素地址是可以被修改的
所以函数内部是可以修改列表、字典、集合、实例等
返回值
要想获取函数的执行结果，就可以用return语句把结果返回
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None
总结：
一旦你的函数经过调用并开始执行，那你的函数外部的程序，就没有办法再控制函数的执行过程了
此时外部程序只能等待函数的执行的结果，为哈要等待函数执行结果，因为外部的程序要根据函数的
执行结果来决定下一步怎么走，这个执行结果就是以return的形式返回给外部程序。
return代表着一个函数的结束。return可以返回任意数据类型的值。
对于用户来说，函数可以返回任意数量的值，对于python程序来说，函数只能返回一个值（如果用户返回多个，函数会统一放到一个元组中）。
递归
def cal(n):
print(n)
if n//2 > 0:
cal(n//2)
cal(10)
def cal(n):
if n//2 > 0:
cal(n//2)
print(n)
cal(10)
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
匿名函数
匿名函数就是不需要显式的指定函数
|
1
2
3
4
5
6
7
8
|
#这段代码def calc(n): return n**nprint(calc(10))#换成匿名函数calc = lambda n:n**nprint(calc(10)) |
|
1
2
3
|
res = map(lambda x:x**2,[1,5,7,4,8])for i in res: print(i) |
输出
1
25
49
16
64
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
|
1
2
3
4
5
6
|
def add(x,y,f): return f(x) + f(y)res = add(3,-6,abs)print(res) |
内置函数
浙公网安备 33010602011771号