Python 集合操作

1.集合操作

集合是一个无序的，不重复的数据组合， 他的主要作业如下。

　　1.去重，把一个列表变成集合，就自动去重了

　　2.关系测试，测试两组数据之前的交集、差集、并集等关系

list_1 = [1,4,5,7,3,6,7,9]
list_1 = set([list_1])
list_2 = set([2,6,0,66,22,8,4])
list_3 = set([1,3,7])
list_4 = set([5,6,8])

#交集：把相同的打印出来
print(list_1 & list_2)
print(list_1.intersection(list_2))
#并集：合并只打印一个重复的
print(list_1 I list_2)
print(list_1.union(list_2))
#差集
print(list_1 - list_2)
print(list_1.difference(list_2))  #list_1打印第list_2没有的数据
print(list_2.difference(list_1))  #list_2打印第list_1没有的数据
#子集
print(list_3.issubset(list_1))
#父集
print(list_2.issuperset(list_4))
#对称差集
print(list_1 ^ list_2)    #合并重复的不打印
print(list_1.symmetric_difference(list_2))
#判断是否是交集
print(list_3.isdisjoint())

#添加
list_3.add(100)
list_3.update([22,44,66])
#删除
list_4.remove(5)    #指定删，没有会报错
list_3.discard(1)   #指定删，没有不会报错
print(list_3,list_4)
list_3.pop()        #随机删
#长度
print(len(list_3))

　　

---

2.文件操作

对文件操作流程

    1.打开问价，得到文件句柄并赋值给一个变量

    2.通过句柄对文件进行操作

    3.关闭文件

现有文件如下

 Somehow, it seems the love I knew was always the most destructive kind
 不知为何，我经历的爱情总是最具毁灭性的的那种
 Yesterday when I was young
 昨日当我年少轻狂
 The taste of life was sweet
 生命的滋味是甜的
 As rain upon my tongue
 就如舌尖上的雨露
 I teased at life as if it were a foolish game
 我戏弄生命 视其为愚蠢的游戏
 The way the evening breeze
 就如夜晚的微风
 May tease the candle flame
 逗弄蜡烛的火苗
 The thousand dreams I dreamed
 我曾千万次梦见
 The splendid things I planned
 那些我计划的绚丽蓝图
 I always built to last on weak and shifting sand
 但我总是将之建筑在易逝的流沙上
 I lived by night and shunned the naked light of day
 我夜夜笙歌 逃避白昼赤裸的阳光
 And only now I see how the time ran away
 事到如今我才看清岁月是如何匆匆流逝
 Yesterday when I was young
 昨日当我年少轻狂
 So many lovely songs were waiting to be sung
 有那么多甜美的曲儿等我歌唱
 So many wild pleasures lay in store for me
 有那么多肆意的快乐等我享受
 And so much pain my eyes refused to see
 还有那么多痛苦 我的双眼却视而不见
 I ran so fast that time and youth at last ran out
 我飞快地奔走 最终时光与青春消逝殆尽
 I never stopped to think what life was all about
 我从未停下脚步去思考生命的意义
 And every conversation that I can now recall
 如今回想起的所有对话
 Concerned itself with me and nothing else at all
 除了和我相关的 什么都记不得了
 The game of love I played with arrogance and pride
 我用自负和傲慢玩着爱情的游戏
 And every flame I lit too quickly, quickly died
 所有我点燃的火焰都熄灭得太快
 The friends I made all somehow seemed to slip away
 所有我交的朋友似乎都不知不觉地离开了
 And only now I'm left alone to end the play, yeah
 只剩我一个人在台上来结束这场闹剧
 Oh, yesterday when I was young
 噢 昨日当我年少轻狂
 So many, many songs were waiting to be sung
 有那么那么多甜美的曲儿等我歌唱
 So many wild pleasures lay in store for me
 有那么多肆意的快乐等我享受
 And so much pain my eyes refused to see
 还有那么多痛苦 我的双眼却视而不见
 There are so many songs in me that won't be sung
 我有太多歌曲永远不会被唱起
 I feel the bitter taste of tears upon my tongue
 我尝到了舌尖泪水的苦涩滋味
 The time has come for me to pay for yesterday
 终于到了付出代价的时间 为了昨日
 When I was young
 当我年少轻狂

读文件

f = open('yesterday','r',encoding='utf-8')
f1 = f.read()
print(f1)
f.close()
f.write('\n我爱北京天安门')

　

打开文件的模式有：

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

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

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

• rU
• r+U

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

• rb
• wb
• ab

f.tell() #把现在的文件句柄所在的指针打印出来。
print(f.flush()) #强制刷新
f.seel(0) #回到那个地方
print(f.encoding) #打印文件编码
print(f.fileno) #返回文件句柄在内存中的编号
f.name() #打印名字
f.isatty() #是不是终端设备
f.readable #判断文件是否可读
f.writable #判断文件是否可写
f.truncate() #截断，如果不写会把文件清空
f.close() #关闭文件

#打印前五行
for i in ragen(5):
　　print(f.readline)

　

 count = 0
 for line in f:
     if count == 9:
         print('----我是分割线----')
         count += 1
         continue
     print(line)
     continue += 1

在10行打印：‘我是分割线’

 impo sys,time

 for i in range(50)
     sys.stdout.write("#")        #标准输出
     sys.stdout.flush()
     time.sleep(0.1)

进度条

 

---

3.字符编码与转换

 

import sys
print(sys.getdefaultencoding())

msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

python2

import sys
print(sys.getdefaultencoding())

msg = "我爱北京天安门"
#msg_gb2312 = msg.decode("utf-8").encode("gb2312")
msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
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)

python3

---

4.函数

1.函数基本语法及特性

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

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

特性:

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

函数定义：

def sayhi():#函数名
    print("Hello, I'm nobody!")

sayhi() #调用函数

可带参数

#下面这段代码
a,b = 5,8
c = a**b
print(c)

#改成用函数写
def calc(x,y):
    res = x**y
    return res #返回函数执行结果

c = calc(a,b) ＃结果赋值给c变量
print(c)

　　

函数参数

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def calc(x,y):  #x,y形参
      res = x**y
      return res
calc(1,2)   #a,b实参，也是位置参数

　　

默认参数

def test(x,y=1):   #y就是是默认参数
      print(x)
      print(y)
test(21)          #如果y的实参不写，默认y=1

　　

关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但是关键参数必须放到位置参数后

test(x=2,y=1)

非固定参数

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

def test1(x,*args):    # *args 会把多传入的参数变成一个元组形式
      print(x)
      print(args)
test1(21)

#输出

  #21 () #后面这个()就是args,只是因为没传值,所以为空

 

   test1(1,2,3,4)

   #输出

   #1 (2,3,4)

　还可以有一个**kwargs　

def test1(x,*args,**kwargs):
      print(x)
      print(args)
test1(21)

#输出
#21 () {} #后面这个{}就是kwargs,只是因为没传值,所以为空

test1(21,12,22,name='alex',age='8')
#输出
#21,(12,22),{'name':'ale','age':'6'}

　　

---

局部变量与全局变量

1.全局与局部变量

　　在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

　　全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

　　当全局变量与局部变量同名时：

　　在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

2.特殊

　　列表，字典，集合，类可以在局部变量里修改。

　　字符串和整数不可以在局部变量里修改

def change_name(name):
    print("before change",name)
    name="Alex li"
    age=23
    print("sfer change",name)

name='alex'
change_name(name)
print(name)

#输出
before change alex
sfer change Alex li
alex

2.返回值

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

注意:

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

3.递归

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

def test(x):
    print(x)
    if int(x/2) > 0:
        return test(int(x/2))
test(10)

　　

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

4.高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):
      return f(x)+f(y)
res = add(3,-6,abs)
print(res)