Python 学习之路 - Python 基础 - (3)

一、集合的使用

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

set_1 = {2, 3, 4, 5, 8, 9}
set_2 = {2, 6, 7, 10, 5, 11}
set_3 = {2, 3, 4, 5}

#交集  &
print(set_1.intersection(set_2))

#并集  |
print(set_1.union(set_2))

#差集  -
print(set_1.difference(set_2))

#对称差集  ^
print(set_1.symmetric_difference(set_2))

#判断是不是子集/父集
print(set_3.issubset(set_1))
print(set_1.issuperset(set_3))

#判断两个集合是否没有交集
print(set_1.isdisjoint(set_2))

#添加member到集合
set_1.add(99)
print(set_1)

#添加多个member到集合
set_2.update([55,56,57])
print(set_2)

#删除member,删除的member不在，抛出异常
set_3.remove(3)
print(set_3)

#删除member,删除的member不在，不抛出异常
set_3.discard(4)
print(set_3)

#随机删除并返回删除的member
print(set_3.pop())
print(set_3)

 

二、文件操作

对文件操作流程

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

注意：读写文件时要注意光标的问题，光标只会自动往下移动

Feel it coming in the air (Yeah)
Hear the screams from everywhere (Yeah)
I'm addicted to the the thrill (I'm ready)
It's a dangerous love affair (Wassup, c'mon)
Can't be scaring nickel's down
Got a problem tell me now (Wassup)
Only thing that's on my mind
Is who gon' run this town tonight (Uh, wassup)
Is who gon' run this town tonight (Yeah, wassup, Yeah)

We gon' run this town
We are, Yeah, I said it, we are
This is Roc Nation, pledge your allegiance
Get ya'll fatigues on, all black everything
Black cards, black cars, all black everything
And our girls are blackbirds, riding with they dillingers
I get more in-depth if you boys really real enough
This is La Familia, I'll explain later
But for now, let me get back to this paper
I'm a couple bands down and I'm tryna get back
I gave doug a grip, I lost a flip for five stacks
Yeah, I'm talking five commas six zeroes dot zeros, here doug
Back to running circles round niggas, now we squared up

Hold up
Life's a game but it's not fair (Yeah)
I break the rules so I don't care (Uh ha)
So I keep doing my own thing
Walking tall against the rain (Wassup)
Victorys within' the mile
Almost there, don't give up now (Wassup)
Only thing that's on my mind
Is who gon' run this town tonight
Hey-ey-ey-ey-ey-ey, ey-ey-ey-ey
Hey-ey-ey-ey-ey-ey, ey-ey-ey-ey

基本操作：

1. 只读文件

f = open('test','r',encoding='utf-8')
print(f.read())
f.close()

2. 只写文件

f = open('test','w',encoding='utf-8')#该文件不存在时创建文件，存在时删除原来的文件内容（文件内容为空）
f.write("ggggggggggggggggg\n")
f.write("kkkkkkkkkkkkkkkkk")
f.close()

3. 只追加写文件

f = open('test','a',encoding='utf-8')
f.write("oooooooooooooo\n")
f.close()

4. 文件的循环

f = open('test','r',encoding='utf-8')
for i in f:
    print(i)
f.close()

文件其它打开模式：

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

• r+，可读写文件。【可读，可追加写】
• w+，写读。【w打开的文件是空的，所以需要先写，后读】
• a+，以附加方式打开可读写文件。【打开文件后，光标在整个文件的末尾】

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

• rU
• r+U

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

• rb
• wb
• ab

f = open("test", "r+", encoding="utf-8")#可读和追加写
f.write("fighting")
print(f.readlines())
f.close()


f = open("test2","w+",encoding="utf-8")#写读
f.write("Fighting for your dream\n")
print(f.readline())
f.close()

f = open("test","a+",encoding="utf-8") #以附加方式打开可读写的文件
f.seek(0)
print(f.readline())
f.write("\njust think you")
f.close()

f = open("test","rb") #以二进制读文件
print(f.readline())
f.close()

f = open("test3","wb") #二进制写文件，文件以二进制的形式保存，但依然显示正常的文字
print(f.write("hello".encode()))
f.close()

 

其它常见用法：

f = open("test","r",encoding="utf-8")
#print(f.readlines()) #把文章全部读出来，按行放在一个列表里
print(f.readline())#读光标开始的那一行
print(f.readline())
print(f.tell())#指出当前光标的位置
f.seek(38)#光标跳转到固定的位置
print(f.readline())
print(f.encoding)#文件编码
print(f.name)#文件名
print(f.seekable())#判断文件光标是否可以移动，返回True或False

f.flush() 用法：立刻把内存上的内容更新到硬盘，以防断电，内存上的内容消失

趣味练习：打印进度条小程序

import sys,time
for i in range(20):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(0.1)

 

with语句

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

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

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

with open ("test","r",encoding="utf-8") as t_r,\
    open("test2","w",encoding="utf-8") as t2_w:
    ...

 

三、字符转码与解码

需知:

1.在python2默认编码是ASCII, python3里默认是utf-8

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-8就是unicode

3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string

 

四、函数

函数是可以实现一些特定功能的小方法或是小程序

解释：简单的理解下函数的概念，就是你编写了一些语句，为了方便使用这些语句，把这些语句组合在一起，给它起一个名字。使用的时候只要调用这个名字，就可以实现语句组的功能了。

Python 内建函数 -- 可以直接使用

python系统中自带的一些函数就叫做内建函数。还有一种是第三方函数，就是其它程序员编好的一些函数，共享给大家使用。

pow()就是一个内建函数，系统自带的。只要正确使用函数名，并添写好参数就可以使用了。

Python 自定义函数

我们自己编些的方便自己工作学习用的函数，就叫做自定义函数了。

定义函数

def 函数名(形式参数):
    代码块

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

注意:

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

 

五、函数的参数

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

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

位置参数

 定义函数时写了几个位置参数，在调用传参时就要传入同样数量的参数。实参与形参一对一。

def add(a,b):
    result = a+b
    return  result

add(5,5)

关键参数

不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

def add(a,b,c):
    result = a+b+c
    return  result

result = add(5,c=6,b=7)
print(result)

默认参数

 把b设置为默认参数，如果形参b没有被赋值，默认值为0，被赋值，就取新的值

def add(a,c,b=0): #关键参数必须放在位置参数后
    result = a+b+c
    return  result

result = add(5,6)
print(result)

非固定参数

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

（1）*args 会把多传入的位置参数变成一个元组形式

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


stu_register("Jeff", 22)
# 输出
# Jeff 22 () #后面这个()就是args,只是因为没传值,所以为空

stu_register("Jack", 32, "CN", "Python")#第一种传参方式
# 输出
# Jack 32 ('CN', 'Python')

stu_register("Amy",18,*("China","IT"))#第二种传参方式
# 输出
# Amy 18 ('China', 'IT')

（2）**kwargs把多传入的关键参数变成一个字典形式

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'}

stu_register("Amy", 18, "CN", "Python", **{"sex":"Fame","province":"DaLian"})
# 输出
#Amy 18 ('CN', 'Python') {'sex': 'Fame', 'province': 'DaLian'}

 

六、局部与全局变量

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

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

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

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

school = "Neusoft"

def change(name):
    global school
    school = "51CTO"  #在局部中改变全局变量
    print("before name:",name)
    name = name.capitalize() #局部变量
    print("after name:", name)

name = "amy wu" #全局变量
change(name)
print(name)
print(school)

输出

before name: amy wu
after name: Amy wu
amy wu
51CTO

 

七、递归

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

递归特性:

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

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

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

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

def calc(number):
    print(number)
    if int(number/2) > 0:
        return  calc(int(number/2))

calc(10)

结果：

10
5
2
1

 

八、高阶函数

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

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