python基础_day3

Posted 2020-10-15

集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：
1、去重，把一个列表变成集合，就自动去重了
2.、关系测试，测试两组数据之前的交集、差集、并集等关系

例子

list_1 = [1,3,4,7,8,4,3]
list_1 = set(list_1)
print(list_1,type(list_1))
#type类型
{1, 3, 4, 7, 8} <class ‘set‘>

基本集合

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:liyanan


list_1 = [1,3,4,7,8,4,3]
list_1 = set(list_1)
#print(list_1,type(list_1))

list_2= [1,5,22,4,9,0]
list_2 = set(list_2)

print(list_1,list_2)

print(list_1.intersection(list_2)) #交集方法1
print(list_1&list_2)#交集方法2
print(list_1.union(list_2))#并集方法1
print(list_1|list_2)#并集方法2
print(list_1.difference(list_2))#差集，在1中不在2中
print(list_1-list_2)#同上
list_3=[5]
list_3=set(list_3)
print(list_3.issubset(list_2))#子集，3在2中
print(list_2.issuperset(list_3))#2包含3
print(list_1.symmetric_difference(list_2))#对称差集方法1，在1和2中列出不同的，不列出相同的
print(list_1^list_2)#对称差集方法2

#输出
{1, 3, 4, 7, 8} {0, 1, 4, 5, 9, 22}
{1, 4}
{1, 4}
{0, 1, 3, 4, 5, 7, 8, 9, 22}
{0, 1, 3, 4, 5, 7, 8, 9, 22}
{8, 3, 7}
{8, 3, 7}
True
True
{0, 3, 5, 7, 8, 9, 22}
{0, 3, 5, 7, 8, 9, 22}

增加

list_1.add(999) #增加一项
list_2.update([88,888,8888])#增加多项
print(list_1,list_2)
#输出
{1, 3, 4, 7, 8} {0, 1, 4, 5, 9, 22}
{1, 3, 4, 7, 8, 999} {0, 1, 4, 5, 9, 8888, 888, 22, 88}

删除

list_2.remove(88) 
print(list_2)
#输出
{0, 1, 4, 5, 9, 8888, 888, 22, 88}
{0, 1, 4, 5, 9, 8888, 888, 22

其他

#摘用alex老师博客
len(s)  
set 的长度  

x in s  
测试 x 是否是 s 的成员  

x not in s  
测试 x 是否不是 s 的成员  

s.issubset(t)  
s <= t  
测试是否 s 中的每一个元素都在 t 中  

s.issuperset(t)  
s >= t  
测试是否 t 中的每一个元素都在 s 中  

s.union(t)  
s | t  
返回一个新的 set 包含 s 和 t 中的每一个元素  

s.intersection(t)  
s & t  
返回一个新的 set 包含 s 和 t 中的公共元素  

s.difference(t)  
s - t  
返回一个新的 set 包含 s 中有但是 t 中没有的元素  

s.symmetric_difference(t)  
s ^ t  
返回一个新的 set 包含 s 和 t 中不重复的元素  

s.copy()  
返回 set “s”的一个浅复制  

文件

对文件操作流程

1、打开文件，得到文件句柄并赋值给一个变量
2、通过句柄对文件进行操作
3、关闭文件

#wenjian
致橡树
　　我如果爱你——
　　绝不像攀援的凌霄花，
　　借你的高枝炫耀自己；
　　我如果爱你——
　　绝不学痴情的鸟儿
　　为绿荫重复单调的歌曲；
　　也不止像泉源
　　长年送来清凉的慰藉；
　　也不止像险峰
　　增加你的高度，衬托你的威仪。
　　甚至日光。
　　甚至春雨。
　　不，这些都还不够！
　　我必须是你近旁的一株木棉，
　　作为树的形象和你站在一起。
　　根，紧握在地下
　　叶，相触在云里。
　　每一阵风吹过
　　我们都互相致意，
　　但没有人
　　听懂我们的言语。
　　你有你的铜枝铁干，
　　像刀、像剑
　　也像戟；
　　我有我红硕的花朵
　　像沉重的叹息，
　　又像英勇的火炬。
　　我们分担寒潮、风雷、霹雳；
　　我们共享雾霭、流岚、虹霓。
　　仿佛永远分离，
　　却又终身相依。
　　这才是伟大的爱情，
　　坚贞就在这里：不仅爱你伟岸的身躯，
　　也爱你坚持的位置，脚下的土地。

基本操作

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:liyanan

f = open(‘wenjian‘,encoding="utf-8")#文件句柄
first_line = f.readline()
print("first line",first_line)#读一行
print(‘我是分割线‘.center(50,‘-‘))
data = f.read()#读取剩下的所有内容，文件大时不要用
print(data)

f.close()

打开文件的模式有：

1、r，只读模式（默认）。
2、w，只写模式。不可读；不存在则创建；存在则删除内容；
3、a，追加模式。可读； 不存在则创建；存在则只追加内容；

例子

#2、w，只写模式。
f = open(‘wenjian2‘,‘w‘,encoding="utf-8")
f.write("我爱北京天安门")

#a，追加模式
f = open(‘wenjian2‘,‘a‘,encoding="utf-8")
f.write("\\n天安门前路很宽\\n")

读取多行

f = open(‘wenjian‘,‘r‘,encoding="utf-8")
for i in range(7):
    print(f.readline())
#输出
致橡树

　　我如果爱你——

　　绝不像攀援的凌霄花，

　　借你的高枝炫耀自己；

　　我如果爱你——

　　绝不学痴情的鸟儿

　　为绿荫重复单调的歌曲；

"+" 表示可以同时读写某个文件
r+，可读写文件。可读；可写；可追加
w+，写读
a+，同a

例子

f = open(‘wenjian‘,‘r+‘,encoding="utf-8")
print(f.readline())
print(f.readline())
print(f.readline())
print(f.tell())
f.write("-------后来加入的--------")
#输出
致橡树

　　我如果爱你——

　　绝不像攀援的凌霄花，

78

但是：

没办法在中间写入，因为内存地址被占用。

修改

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:liyanan

f = open("wenjian2",‘r‘,encoding=‘utf-8‘)
f_new = open("wenjian2.new",‘w‘,encoding=‘utf-8‘)

for line in f:
    if "路很宽" in line:
        line = line.replace("路很宽","地方大")
    f_new.write(line)
f.close()
f_new.close()
#执行后新增加一个wenjia2.new文件而且内容是

"U"表示在读取时，可以将 \\r \\n \\r\\n自动转换成 \\n （与 r 或 r+ 模式同使用）
rU
r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
rb
wb
ab

其他操作

for index ,line in enumerate(f.readlines()):
    if index == 3:
        print(‘------我是分割线-------‘)
        continue
    print(line.strip())
#输出
致橡树
我如果爱你——
绝不像攀援的凌霄花，
------我是分割线-------
我如果爱你——
绝不学痴情的鸟儿
为绿荫重复单调的歌曲；
也不止像泉源
。。。

f = open(‘wenjian2‘,‘r‘,encoding="utf-8")
print(f.tell())
print(f.readline())
print(f.tell())
#输出 ，读取了23个字符。
0
我爱北京天安门

23

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open("wenjian","r",encoding="utf-8") as f:
    print(f.readline())

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

with open("wenjian","r",encoding="utf-8") as f,        open("wenjian2","r",encoding="utf-8") as f2:
    print(f2.readline())

字符编码转换

Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分，不再会对bytes字节串进行自动解码。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string。

例子

msg = "我"
msg_gb2312=msg.encode("gb2312")#py3默认是unicode
gb2312_to_unicode=msg_gb2312.decode("gb2312")
gb2312_to_utf8=msg_gb2312.decode("gb2312").encode("utf-8")

print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)
#输出
我
b‘\\xce\\xd2‘
我
b‘\\xe6\\x88\\x91‘

---

函数

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

特征：
1、减少重复代码
2、使程序变的可扩展
3、使程序变得易维护

标准定义：

def hello():#函数名
    print("你好")

hello()#调用函数

带参数：

def jia(x,y):
    jia = x+y
    return jia#返回函数执行结果
c = jia(1,3)
print(c)
#输出
4

---

参数

形参：
变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参：
可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

---

默认参数

def list(name,age,salary="1000"):
    print("-----list-----")
    print("姓名",name)
    print("age",age)
    print("工资",salary)

list("张三",1,100)
list("李四",2,200)
list("王五",3)
#输出
-----list-----
姓名 张三
age 1
工资 100
-----list-----
姓名 李四
age 2
工资 200
-----list-----
姓名 王五
age 3
工资 1000

在调用list这个函数中，王五的salary不输入，默认使用salary="1000"，这个默认值。指定了的话，就用你指定的值。

关键参数（特别注意）
正常情况下，给函数传参数要按顺序，不按顺序就可以用关键参数，指定参数名即可，注意：关键参数必须放在位置参数之后。

list(age="4",salary="400",name="一一")

---

非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def test(x,*args):
    print(x)
    print(args)
test(1,2,3,4)
#输出
1
(2, 3, 4)

*args 会把多传入的参数变成一个元组形式

def test4(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)

test4(‘liyanan‘,age=‘24‘,sex=‘man‘,salary=‘6000‘)
#输出
liyanan
24
{‘sex‘: ‘man‘, ‘salary‘: ‘6000‘}

*kwargs 会把多传入的参数变成一个dict形式

---

全局变量和局部变量

school = "oldboy edu" #全局变量

def school_name(school):

    print("改之前",school)
    school = "mage linux" #局部变量
    print("改之后",school)

school_name(school)

print(school)
#输出
改之前 oldboy edu
改之后 mage linux
oldboy edu

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

---

返回值
要想获取函数的执行结果，就可以用return语句把结果返回

注意:

1、函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2、如果未在函数中指定return,那这个函数的返回值为None

---

递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def jia(n):
    print(n)
    if int(n+n)<100:
        return jia(int(n+n))
    print("--->",n)

jia(1)
#输出
1
2
4
8
16
32
64
---> 64

递归特性:
1、必须有一个明确的结束条件
2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3、递归效率不高，递归层次过多会导致栈溢出

---

高阶函数
一个变量可以使用函数，那么这个函数就可以接受另一个函数作为参数，这叫高阶函数。