声明 ：
文档内容学习于
http://www.cnblogs.com/xiaozhiqi/
一、 集合
集合是一个无序的，不重复的数据组合，主要作用如下
1.去重 把一个列表变成集合 ，就自动去重了
2.关系测试，测试2组数据的之前的交集，差集，并集等关系
去重，直接将列表变成集合
[root@master day3]# cat set.py
#!/usr/bin/env python3
list = [1,2,5,8,5,6,7,7]
list = set(list)
print (list,type(list)) [root@master day3]# ./set.py
{1, 2, 5, 6, 7, 8} <class 'set'> #直接去重了
交集， intersection 。 就是将2个列表中，相同的取出来
下面list 和list2中 5和 8是重复，可以直接将他们取出。
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list2 = set([5,555,256,777,8])
print ( list.intersection(list2)) [root@master day3]# ./set.py
{8, 5}
并集（合集）， union 2个列表合并去重
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list2 = set([5,555,256,777,8])
print ( list.union(list2)) [root@master day3]# ./set.py
{256, 1, 2, 5, 6, 7, 8, 777, 555}
差集，difference 就是2个列表，对比。打印独有部分
[root@master day3]# cat ./set.py
#!/usr/bin/env python3
list = [1,2,5,8,5,6,7,7]
list = set(list)
list2 = set([5,555,256,777,8])
print ( list.difference(list2)) #将list和list2对比。打印只有list中独有的部分 [root@master day3]# ./set.py
{1, 2, 6, 7}
对称差集
就是将2个列表中，相互没有的都取出来了。
[root@master day3]# cat ./set.py
#!/usr/bin/env python3
list = [1,2,5,8,5,6,7,7]
list = set(list)
list2 = set([5,555,256,777,8])
print ( list.symmetric_difference(list2)) [root@master day3]# ./set.py
{256, 1, 2, 6, 7, 777, 555}
子集，父集
是否存在包含的关系
[root@master day3]# cat ./set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list3 = set([1,7]) list = set(list)
list2 = set([5,555,256,777,8]) print ( list.issubset(list2)) #子集，是否被包含
print ( list3.issubset(list))
print ( list.issuperset(list2)) #父集，是否包含
print ( list.issuperset(list3)) [root@master day3]# ./set.py
False
True
False
True
判断是否有交集 isdisjoint
如果2个列表没有交集， 就返回ture。
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list2 = set([5,555,256,777,8])
list3 = set([1,6])
print ( list3.isdisjoint(list))
print ( list3.isdisjoint(list2)) [root@master day3]# ./set.py
False
True
也可以使用以下字符串进行操作
s | t s和t的并集
s & t s和t的交集
s - t 求差集
s ^ t 求对称差集
len(s) 集合中项数
max(s) 最大值
min(s) 最小值
添加
add 添加一项
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list.add("ssdd") print ( list )
[root@master day3]# ./set.py
{1, 2, 5, 6, 7, 8, 'ssdd'}
update 添加多项
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list.update([555,666,888])
print ( list ) [root@master day3]# ./set.py
{1, 2, 5, 6, 7, 8, 555, 888, 666}
删除
remove，因为集合本生就是去重的，所以，删除的话。就是都删除了 。
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list.remove(2)
print ( list ) [root@master day3]# ./set.py
{1, 5, 6, 7, 8}
pop 随机删除 。
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list)
list.pop()
print (list) [root@master day3]# ./set.py
{2, 5, 6, 7, 8}
discard
也是删除，和remove相似，但是remove指定一个不存在的值的时候会报错、discard不会报错
[root@master day3]# cat set.py
#!/usr/bin/env python3 list = [1,2,5,8,5,6,7,7]
list = set(list) list.discard(555) #指定不存在的值，程序也不会报错。
list.discard(8) print (list) [root@master day3]# ./set.py
{1, 2, 5, 6, 7}
文件操作
文件操作步骤
1. 打开文件
2.通过文件句柄进行操作
3.关闭文件
基本的文化操作
读取文件
linux中
当文件和脚本在同一个目录下时， 可以直接打开
[root@localhost python]# ls
dictionary.py file_op.py guess.py name2.py name.py tuple.py yesterday.txt
[root@localhost python]# cat file_op.py
#!/usr/bin/env python3 data = open ("yesterday.txt").read() #直接打开文件
print (data)
[root@localhost python]#
windows中
因为windows 默认是 GBK的编码格式， 所以在windows中打开的话。需要定义编码字符集
# Author ricky
data = open("yesterday",encoding="utf-8" ).read() # 定义字符集
print (data )
否则会报错
Traceback (most recent call last):
File "E:/个人/python/day3/file_op.py", line 3, in <module>
data = open("yesterday").read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0x80 in position 124: illegal multibyte sequence
这是读取了文件，一般情况下，如果要修改。就是会将打开这个文件写成一个变量。
f = open("yesterday",encoding="utf-8")
data = f.read()
print (data )
f.close() # 关闭文件
然后读取文件的话，其实就是加载文件到内存中。 然后你的程序的光标，其实就是第一次读的内存指针。所以当有第二个变量指过去的时候。其实还是现实是之前的内存指针。
[root@localhost python]# cat yesterday.txt
aaaaaa
bbbbbb
ccccc
[root@localhost python]# cat ./file_op.py
#!/usr/bin/env python3 f = open ("yesterday.txt") data = f.read()
data2 = f.read()
print ( data )
print ( "data2==============", data2 ) [root@localhost python]# ./file_op.py
aaaaaa
bbbbbb
ccccc data2==============
逐行读取 readline
read是读取全部文件， readline 是逐行读取
[root@master day3]# cat yesterday.txt
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
就像雨滴滴落我的舌尖
I teased at life as if
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt")
print (f.readline()) [root@master day3]# ./file_op.py
seems the love I've known,
读取前5行
可以用for循环+ readline实现
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") for i in range(5):
print (f.readline()) f.close() [root@master day3]# ./file_op.py
seems the love I've known, 看起来我所知道的爱情 has always been the most destructive kind. 好像总是变成破坏性的那种 I guess that's why now I feel so old before my time.
打印全部文件
可以直接用for进行循环
这种循环效率最好。他就是加载一行，打印一行，然后内存中再去除一行 。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt")
for i in f:
print ( i.strip() ) f.close() [root@master day3]# ./file_op.py
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
就像雨滴滴落我的舌尖
I teased at life as if
指定打印到某一行。 将这行进行输出（---------）。
可以自己写个计数器，然后进行判断
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt")
count = 0
for i in f :
if count == 5:
print ("=====================")
print ( i.strip() )
count += 1 f.close() [root@master day3]# ./file_op.py
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
=====================
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
就像雨滴滴落我的舌尖
I teased at life as if
打印5到 10行
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt")
count = 0 for i in f :
if count >= 5 and count <= 10 :
print ( i.strip() )
count += 1 f.close() [root@master day3]# ./file_op.py
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
还有一种方法
可以使用readlines
注意 是readlines 不是readline。
readlines 将文件内容，变成了列表。 所以他每次都会将整个文件进行转换。 如果是大文件。会影响性能。所以不推荐。
但是 ， 因为列表有下标。 所以。在处理小文件的时候。 可能会写起来方便点。 但是不推荐。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") for i in f.readlines():
print ( i.strip() ) # 可以使用 strip 去掉多于的空行和空格 f.close()
[root@master day3]# ./file_op.py
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
就像雨滴滴落我的舌尖
I teased at life as if
指定打印到某一行。 将这行进行输出（---------）。
其实 readlines 是将文件变成了 列表。 所以每个元素都是都下标。我们可以使用下标进行判断，来实现。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") for index,line in enumerate(f.readlines()):
if index == 5 :
print ( "-------------------------" )
print ( line.strip() ) f.close() [root@master day3]# ./file_op.py
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
-------------------------
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
As rain upon my tongue
就像雨滴滴落我的舌尖
I teased at life as if
这样也可以实现，打印5-10的内容
注意下标是从 0 开始的。 所以要算好行数。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") for index,line in enumerate(f.readlines()):
if index > 5 and index < 10:
print ( index , line.strip() )
f.close() [root@master day3]# ./file_op.py
6 Yesterday When I was young
7 往日当我还年轻时
8 The taste of life was sweet
9 生命的感受如此美好
写文件
在python中。 如果打开文件后，需要制定操作类型， 读了 就不能写。 写了就不能读。
r 读取文件
[root@localhost python]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday.txt","r") data = f.read()
data2 = f.read() print ( data )
print ( "data2==============", data2 )
[root@localhost python]# ./file_op.py
aaaaaa
bbbbbb
ccccc data2==============
w 写文件
这边需要注意，写文件的话，w参数每次写都是覆盖。 会将原本的文件内容删除。
[root@localhost python]# cat yesterday.txt
aaa
bbb
ccc
[root@localhost python]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday.txt","w")
f.write ("123456789")
[root@localhost python]# ./file_op.py
[root@localhost python]# cat yesterday.txt
123456789[root@localhost python]#
同时 他也可以创建新的文件
[root@localhost python]# ls
dictionary.py file_op.py guess.py name2.py name.py tuple.py yesterday.txt
[root@localhost python]# cat file_op.py
#!/usr/bin/env python3 f = open ("tomorrow.txt","w")
f.write ("123456789")
[root@localhost python]# ./file_op.py
[root@localhost python]# ls
dictionary.py file_op.py guess.py name2.py name.py tomorrow.txt tuple.py yesterday.txt
a append 追加写
[root@localhost python]# cat yesterday.txt
123456789 [root@localhost python]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday.txt","a") f.write ("ppp\n")
f.write ("ooo\n")
[root@localhost python]# ./file_op.py
[root@localhost python]# cat yesterday.txt
123456789 ppp
ooo
其他的一些使用方法
tell
就是告诉你现在的文件指针位置的。 注意：它不是按行来算的，是字符串的位置来算的。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") print (f.tell())
print(f.readline().strip())
print (f.tell())
f.close() [root@master day3]# ./file_op.py
0
seems the love I've known,
27
seek
指定文件指正到固定位置。实际情况中，因为使用中，因为你不能确定，具体的字符串的位置。所以一般都是指向0。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday.txt") print (f.tell())
print(f.readline().strip())
print (f.tell())
f.seek(0)
print (f.tell())
print(f.readline().strip())
f.close() [root@master day3]# ./file_op.py
0
seems the love I've known,
27
0
seems the love I've known,
flush
一般我们写，读文件都是先存储到内存中的 ，当到了一定的量之后，它才会写到磁盘上面。 flush就是可以使 立刻将内存中的内容写到磁盘上面。
这个在window上进行测试
现在有个空文件
111.txt
然后插入一条语句
E:\>python
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:53:40) [MSC v.1500 64 bit (
AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> f = open("111.txt",'w')
>>> f.write("hello")
再次打开，发现文件还是空的。
这个时候输入
>>> f.flush()
再次打开文件， 发现文件有内容了。
可以用来打印进度条 ，可以试试下面的代码。
# Author ricky import sys,time for i in range(20):
sys.stdout.write ( "#") # 用sys模块 标准输出，写。
sys.stdout.flush() # 时时刷新
time.sleep(0.1) # 使用time模块。延时
truncate
截断
我们现在有这个一个文件，
[root@localhost day3]# cat yesterday2.txt
When I was young
当我小时候
I'd listen to the radio
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
When they played I'd sing along
当歌曲播放时我和着它轻轻吟唱
[root@localhost day3]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday2.txt",'a')
f.truncate() # 直接使用的话，看不出效果，因为没有指定从哪里截断。 [root@localhost day3]# ./file_op.py
[root@localhost day3]#
[root@localhost day3]# cat yesterday2.txt
When I was young
当我小时候
I'd listen to the radio
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
When they played I'd sing along
当歌曲播放时我和着它轻轻吟唱
这边输入数字， 从哪个字段开始截断
[root@localhost day3]# cat yesterday2.txt
When I was young
当我小时候
I'd listen to the radio
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
When they played I'd sing along
当歌曲播放时我和着它轻轻吟唱
[root@localhost day3]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday2.txt",'a')
f.truncate(10) #从第10个字段开始截断 [root@localhost day3]# ./file_op.py
[root@localhost day3]#
[root@localhost day3]#
[root@localhost day3]# cat yesterday2.txt
When I was[root@localhost day3]#
和seek配合，可以指定删除的范围
以下从第10个字符开始算。往后截取10个字符。 后面的截断。 其实就是保留了 20个字符
[root@localhost day3]# cat yesterday2.txt
When I was young
当我小时候
I'd listen to the radio
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
When they played I'd sing along
当歌曲播放时我和着它轻轻吟唱
It made me smile
我脸上洋溢着幸福的微笑 [root@localhost day3]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday2.txt",'a')
f.seek(10)
f.truncate(20) [root@localhost day3]#
[root@localhost day3]# ./file_op.py
[root@localhost day3]#
[root@localhost day3]# cat yesterday2.txt #保留了20个字符
When I was young
当[root@localhost day3]#
读写 r+
可以用于打开文件，然后追加内容。
通过以下我们可以看到。他是写在最后一行的 。可以同时读和写。
[root@localhost day3]# cat yesterday2.txt
所有我喜爱万分的歌曲
Every shalala every wo'wo
每一个shalala每一个wo‘wo
still shines
仍然光芒四射
Every shing-a-ling-a-ling
每一个shing-a-ling
that they're starting to sing
每一个他们开始唱的
so fine
都如此悦耳
Wen they get to the part
当他们唱到他
[root@localhost day3]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday2.txt",'r+') print ( f.readline() )
print ( f.readline() )
print ( f.readline() )
f.write("=========")
print ( f.readline() ) [root@localhost day3]# ./file_op.py
所有我喜爱万分的歌曲 Every shalala every wo'wo 每一个shalala每一个wo‘wo [root@localhost day3]# cat yesterday2.txt
所有我喜爱万分的歌曲
Every shalala every wo'wo
每一个shalala每一个wo‘wo
still shines
仍然光芒四射
Every shing-a-ling-a-ling
每一个shing-a-ling
that they're starting to sing
每一个他们开始唱的
so fine
都如此悦耳
Wen they get to the part
当他们唱到他
=========[root@localhost day3]#
写读 r+
貌似实际场景中用的不多。
他是先写再读，但是此处需注意。 他会将原有的文件先清空在重新开始写的 。然后才能读。
[root@master day3]# cat yesterday2.txt
seems the love I've known,
看起来我所知道的爱情
has always been the most destructive kind.
好像总是变成破坏性的那种
I guess that's why now I feel so old before my time.
我猜这就是为什么我感到如此苍老，比起我的真实年龄
Yesterday When I was young
往日当我还年轻时
The taste of life was sweet
生命的感受如此美好
[root@master day3]# cat file_op.py #!/usr/bin/env python3 f = open("yesterday2.txt","w+")
f.write("---------dao1-----------\n")
f.write("---------dao2-----------\n")
f.write("---------dao3-----------\n")
f.write("---------dao4-----------\n")
f.seek(0) #回到第一个字符，开始读，因为写的时候，其实已经在最后一个字符串了
print (f.readline())
print (f.readline()) f.close() [root@master day3]# ./file_op.py
---------dao1----------- ---------dao2----------- [root@master day3]#
[root@master day3]# cat yesterday2.txt
---------dao1-----------
---------dao2-----------
---------dao3-----------
---------dao4-----------
rb 读取2进制的文件
查看一下。可以看在用2进制的方式读取文件。 前面会有b开头（binary）
linux上处理
[root@master day3]# cat yesterday2.txt
---------dao1-----------
---------dao2-----------
---------dao3-----------
---------dao4-----------
[root@master day3]# cat file_op.py
#!/usr/bin/env python3
f = open("yesterday2.txt","rb")
print (f.read())
f.close() [root@master day3]# ./file_op.py
b'---------dao1-----------\n---------dao2-----------\n---------dao3-----------\n---------dao4-----------\n'
windows上处理
需注意，因为之前windows上面有encoding编码的。 如果直接用2进制打开会报错。
所以在windows上面需要用2进制的话，需要将encoding去掉，就可以了。
wb
2进制写。
[root@master day3]# cat file_op.py
#!/usr/bin/env python3 f = open("yesterday2.txt","wb") f.write( "hello binary".encode()) #需要将字符串转换成2进制 f.close() [root@master day3]# ./file_op.py
[root@master day3]# cat yesterday2.txt
hello binary[root@master day3]#
修改文件中内容
要修改文件中的内容，其实只有2中方法。
1.打开文件，加载在内存中，进行修改，在保存在磁盘中， 就像 vim 这种的。
2. 读取老文件，进行修改，然后弄到新文件。
[root@localhost day3]# cat yesterday2.txt
When I was young
当我小时候
I'd listen to the radio
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
[root@localhost day3]# cat file_op.py
#!/usr/bin/env python3 f = open ("yesterday2.txt",'r')
f_new = open ("yesterday2.new",'w') for line in f:
if "I'd listen to the radio" in line:
line = line.replace("I'd listen to the radio","I'd watch the television") # 使用字符串替换， 替换需要修改的字符串
f_new.write(line) f.close()
f_new.close() [root@localhost day3]# ./file_op.py
[root@localhost day3]# ls
file_op.py yesterday2.new yesterday2.txt yesterday.txt
[root@localhost day3]# cat yesterday2.new
When I was young
当我小时候
I'd watch the television
聆听收音机
Waitng for my favorite songs
等着我最喜欢的歌曲
for循环， 可以做如下理解。就是不管是不是判断到 字符串是否有进行替换， 都会写。
for line in f:
if "I'd listen to the radio" in line:
line = line.replace("I'd listen to the radio","I'd watch the television")
f_new.write(line) 其实等于 for line in f:
if "I'd listen to the radio" in line:
line = line.replace("I'd listen to the radio","I'd watch the television")
f_new.write(line)
else:
f_new.write(line)
with 语句
我们常常会忘记关闭文件。 with可以帮助我们关闭文件
格式
with open( "yesterday2",'r',encoding="utf-8") as f :
for line in f:
print( line )
其实就是将写变量的形式 改了。 然后这个就不用为close 担心了。
f = open( "yesterday2",'r',encoding="utf-8") 改 with open( "yesterday2",'r',encoding="utf-8") as f :
同时 可以打开多个
with open( "yesterday2",'r',encoding="utf-8") as f , open( "yesterday3",'r',encoding="utf-8") as g :
for line in f:
print( line )
可以写的工整点
with open( "yesterday2",'r',encoding="utf-8") as f , \
open( "yesterday3",'r',encoding="utf-8") as g :
for line in f:
print( line
函数 和 函数式编程
面向对象
主要方式 是 类 ---》 class
面向过程
主要方式是 过程---》 def
函数式编程
主要方式 函数 ---》 def
格式
# 函数式编程
def func1(): # 定义函数
'''testing 111 ''' # 注释
print ("in the func1") # 函数内容
return 0 # 返回值 # 面向过程 和函数式相比就少了个 返回值。过程就像没有返回值的函数
def func2():
'''testing 222'''
print ("in the func2")
关于return 的 总结：
1.没有返回值。 返回 none
2.返回值=0， 返回object(对象)
3.返回值>0, 返回tuple（元组）
root@localhost day3]# ./func.py
in the func1
in the func2
in the func3
None
0
(0, 'aaa', ['aaa', 'bbb'], {'aaa': 'bbb'})
[root@localhost day3]# clear
[root@localhost day3]# lsc
-bash: lsc: command not found
[root@localhost day3]# clear
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1():
'''testing 111 '''
print ("in the func1") def func2():
''' testing222'''
print ("in the func2")
return 0 def func3():
'''testing333'''
print ('in the func3')
return 0 ,('aaa'), ['aaa','bbb'],{'aaa':'bbb'} a = func1()
b = func2()
c = func3() print (a)
print (b)
print (c) [root@localhost day3]# ./func.py
in the func1
in the func2
in the func3
None
0
(0, 'aaa', ['aaa', 'bbb'], {'aaa': 'bbb'})
[root@localhost day3]#
函数赋值
位置参数
可以给函数赋值， 但是当运行函数的时候，一定要把值写进去。否则会报错
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(x,y): # 这里的x y 叫形参
'''testing 111 '''
print ( x )
print ( y )
return 0 func1 (1,2) # 这里的x y 叫实参，顺序于形参一一对应 [root@localhost day3]# ./func.py
1
2
关键字调用
也可以这么写
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(x,y):
'''testing 111 '''
print ( x )
print ( y )
return 0 func1 (y=2,x=1) # 这个叫关键字调用 [root@localhost day3]# ./func.py
1
2
有可以2者混用
这边有个地方需要注意， 就是位置参数一定要写在关键字参数的前面， 否则会报错 。
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(x,y,z):
'''testing 111 '''
print ( x )
print ( y )
print ( z )
return 0 func1 (2,z=1,y=6) [root@localhost day3]# ./func.py
2
6
1
默认参数
就是形参的时候，直接就给赋值了。
特点：
1.调用函数的时候，默认参数非必须传递。 可用于，安装时候的默认安装
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(x,y=2):
'''testing 111 '''
print ( x )
print ( y )
return 0 func1 (4) [root@localhost day3]# ./func.py
4
2
参数组
当实参的数量确定不了的时候。 我们可以使用参数组。 这样就不会报错 了。
可以接受N个 位置参数。转换成元组的形式。
def func1(*args):
'''testing 111 '''
print (args) func1(1,2,3,4,5,6)
字典形式传参
**kwagrs ： 把N个关键字参数，转换成字典的方式。
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(**kwargs): #固定格式
'''testing 111 '''
print (kwargs) func1 ( name = 'alex', age = '11' , sex = 'f' ) [root@localhost day3]# ./func.py
{'name': 'alex', 'age': '11', 'sex': 'f'}
也可以单独把 当个元素 取出来。
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(**kwargs):
'''testing 111 '''
print (kwargs)
print (kwargs['name'])
print (kwargs['age'])
print (kwargs['sex']) func1 ( name = 'alex', age = '11' , sex = 'f' ) [root@localhost day3]# ./func.py
{'name': 'alex', 'age': '11', 'sex': 'f'}
alex
11
f
也可以和 其他参数一起使用
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def func1(name,age=18,**kwargs): #和默认参数，位置参数一起使用
'''testing 111 '''
print (name)
print (age)
print (kwargs) func1 ( 'AAAA', hobby = 'hahaha' , sex = 'f' ) [root@localhost day3]# ./func.py
AAAA
18
{'hobby': 'hahaha', 'sex': 'f'} #将关键字参数变成了字典的形式
函数套 函数
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def logger (source):
print ("from %s" %source ) def func1(name,age=18,**kwargs):
'''testing 111 '''
print (name)
print (age)
print (kwargs)
logger ("test4") # 函数套函数 func1 ( 'AAAA', hobby = 'hahaha' , sex = 'f' ) [root@localhost day3]# ./func.py
AAAA
18
{'hobby': 'hahaha', 'sex': 'f'}
from test4
局部变量
就是将一个变量封在函数中， 而不影响全局变量
在子程序中定义的变量称为局部变量 。在程序的一开始定义的变量称为全局变量。
全局变量的作用域是整个程序，局部变量的作用域是定义改变量的子程序。
当全局变量和局部变量同名的时候：
在定于局部变量的子程序内，局部变量起作用，其他地方全局变量起作用。
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def change_name(name):
print ("before name",name)
name = "BBBB" #这函数就是这个这个变量的作用域，只在函数里面生效
print ("after name", name) name = "aaaa"
print(name)
change_name(name)
print(name) [root@localhost day3]# ./func.py
aaaa #函数外
before name aaaa #函数内
after name BBBB #函数内
aaaa #函数外
函数中定义全局变量
上面我们看到，函数中变量值能在函数中生效。 但是如果我们要强行在函数中定义全局变量，也能实现。
使用global
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 country = "china" def change():
global country
country = "USA"
print (country) print (country)
change()
print( country )
[root@localhost day3]# ./func.py
china
USA
USA
但是这里我们要注意一个问题。 如果我们要在函数中定义全局变量。 则在定义之前。我们不能在函数中调用这个变量 ，否则会报错 。如下 。
在定义global之前，就使用这个变量了。
然后运行的时候回报错。
所以在函数中使用全局变量。 在定义前。不能使用。
局部变量中的，列表、字典等复杂变量可以全局生效。
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 name = [ 'aaa','bbb','ccc'] def change_name():
print ( "inside", name )
name[0] = ('11111') change_name()
print (name) [root@localhost day3]# ./func.py
inside ['aaa', 'bbb', 'ccc']
['11111', 'bbb', 'ccc']
递归
就是自己调用自己
[root@localhost day3]# cat recursion.py
#!/usr/bin/env python3 def calc (n):
print(n)
return calc(n+1) #返回的 调用自己的函数，是自己的函数+1 calc(0)
[root@localhost day3]# ./recursion.py
0
1
2
调用的函数 最多只有 999层。之后就会报错了
递归的特性：
1. 必须有一个明确的结束条件
2.每次进入更深一层递归时，问题的规模比上次递归的应有所较少。
3.递归的效率不高，递归的层次过多会导致栈溢出。
以下递归是，给他一个值。并且一直除以2，并且保持整数的情况下，要大于0，才执行。
[root@localhost day3]# cat recursion.py
#!/usr/bin/env python3 def calc (n):
print(n)
if int(n) > 0:
return calc(int(n/2))
calc(10) [root@localhost day3]# ./recursion.py
10
5
2
1
0
高阶函数（此处可以和day4的 装饰器 一起看 ， 有助于理解 ）
函数里面可以有参数。如果一个函数里面接受另一个函数作为参数，那这种函数就是高阶函数。
1. 把一个函数名当做实参传给另一个函数
2. 返回值中包含函数名
[root@localhost day3]# cat func.py
#!/usr/bin/env python3 def add (a,b,f):
return f(a) + f(b) res = add(3,-6,abs) #abs其实是内置函数（这样就是函数调函数）， 是取绝对值的意思（就是都是正数）本来是（-6+3）应该等于-3. 但是都是绝对值的话就是（6+3）。那就是9，
# 此处需要注意，这边是传函数，不是传函数的执行结果，所有不能abs()这么写
print(res) [root@localhost day3]# ./func.py
9
匿名函数
就是不用定义名字的函数、使用lambda函数
[root@localhost day4]# cat decorator1.py
#!/usr/bin/env python3 calc = lambda x:x*3
print ( calc (3)) [root@localhost day4]# ./decorator1.py
9
内置函数
python 有许多内置的函数。
参考:
https://www.runoob.com/python/python-built-in-functions.html
abs() ： 取绝对值
abs(-45) : 45
abs(100.12) : 100.12
abs(119L) : 119
all() ： 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 元素除了是 0、空、None、False 外都算 True。
>>> all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3]) # 列表list，存在一个为0的元素
False >>> all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
False
>>> all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素
False >>> all([]) # 空列表
True
>>> all(()) # 空元组
True
any() : 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。只要有一个是True，就是True
>>>any(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True >>> any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
True >>> any([0, '', False]) # 列表list,元素全为0,'',false
False >>> any(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True >>> any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
True >>> any((0, '', False)) # 元组tuple，元素全为0,'',false
False >>> any([]) # 空列表
False >>> any(()) # 空元组
False
bin() 把一个整数（int）十进制转2进制
>>> bin(1)
'0b1'
>>> bin(2)
'0b10'
>>> bin(4)
'0b100'
>>> bin(255)
'0b11111111'
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。就是将数据转为bool值。没有就是false
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int) # bool 是 int 子类
True
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
正常情况下，字节是不能修改的，使用 bytearray就能修改字节了。
[root@master day4]# cat func.py
#!/usr/bin/env python3 a =bytes("abcd",encoding="UTF-8") # 数据类型类型为字节
print (a.capitalize(),a) # capitalize() 首字母大写。 b = bytearray("abcd",encoding="UTF-8") # 使用 bytearray()
print (b[0]) # 打印"abcd"的第一个数据，也就是"a"
b[0] = 70 # 进行修改，不能字节输入数据内容，只能是ascII对应的数字 也就是 在 0--256的范围内
print (b) # 再次打印， 会发现原来的数据变化了。 [root@master day4]# ./func.py
b'Abcd' b'abcd' # 第一次打印出来的a 是大写。 但是其实数据本生没有变化
97 # 可以看到 打印出来的 其实是 "a" 这个字节ascII 的位置。
bytearray(b'2bcd') # 可以看到 原来的a（ascII 97） 变成现在的2（ascII 70）
callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
像函数 这种 需要定义的 后面有（）的， 里面可以传参的 。这种就是可调用的， 比如： 函数，类
>>>callable(0) # 数字不可调用
False
>>> callable("runoob") # 字符串不可调用
False
>>> callable([1,2,30]) # 列表不可调用
False
>>> def add(a, b):
... return a + b
...
>>> callable(add) # 函数返回 True
True
chr() 用一个范围在 range（256）内的 将数字 转为ascII。 和 ord() 相对。
>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97) # 十进制
0 1 a
compile() 函数将一个字符串编译为字节代码。
不知道干嘛用的 。 视频里说 import 只能导入本地的模块 。 用compile() 在某种情况下 可以相当于导入异地的模块。
>>>str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec') # 编译为字节代码对象
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
dict() 函数用于创建一个字典。 功能其实和直接（） 创建字典一样 。
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>>
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
普通for循环
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
... print i, seq[i]
... i +=1
...
0 one
1 two
2 three
用了 enumerate() 的循环
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print i, element
...
0 one
1 two
2 three
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
只能处理简单的数字这种。比如，运算。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
execfile() 函数可以用来执行一个文件。
假设文件 hello.py，内容如下：
print('runoob');
execfile 调用该文件
>>>execfile('hello.py')
runoob
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
#!/usr/bin/python
# -*- coding: UTF-8 -*- def is_odd(n):
return n % 2 == 1 # 余数等于1. 就是不能整除。 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # 赋值的方式有点不一样，需要加，
print(newlist)
输出结果 ：
[1, 3, 5, 7, 9]
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
>>>a = frozenset(range(10)) # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合
globals() 函数会以字典类型返回当前位置的全部全局变量。
而且返回的值，是以字典的形式 。变量名是key，变量是value。
>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。， 就是生成一个对应的 hash值。
>>>hash('test') # 字符串
2314058222102390712
>>> hash(1) # 数字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
help() 函数用于查看函数或模块用途的详细说明
>>>help('sys') # 查看 sys 模块的帮助
……显示帮助信息……
>>>help('str') # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a) # 查看列表 list 帮助信息
……显示帮助信息……
>>>help(a.append) # 显示list的append方法的帮助
……显示帮助信息……
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'> # 字符串
id() 函数用于获取对象的内存地址。
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
input() 函数接受一个标准输入数据，返回为 string 类型。
>>> a = input ("please input you name:")
please input you name:aaa
>>> print ( a )
aaa
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True
True
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
class A:
pass class B(A):
pass isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
locals() 函数会以字典类型返回当前位置的全部局部变量。和golbals 类似。 但是
globals() 只打印全局变量，不打印局部变量
locals() 只打印局部变量，不打印全局变量
[root@localhost day4]# cat func.py
#!/usr/bin/env python3 def test():
local_var = 333
print (locals())
test()
print (globals())
print (globals().get('local_var')) [root@localhost day4]# ./func.py
{'local_var': 333} # 使用locals局部变量
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fdb7af91828>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': './func.py', '__cached__': None, 'test': <function test at 0x7fdb7afc1e18>}
None # 使用globals 其实是没有那个变量的
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。 生成的是列表。
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
next() 返回迭代器的下一个项目
oct() 函数将一个整数转换成8进制字符串。
>>>oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'
>>>
open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
>>>f = open('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值。
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
pow() 方法返回 xy（x的y次方） 的值。
>>> pow(3,6) # 3的6次方
729
>>> pow(10,6) # 10的6次方
1000000
>>> pow(2,6) # 2的6次方
64
>>> pow(2,8) # 2的8次方
256
repr() 函数将对象转化为供解释器读取的形式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
reverse() 函数用于反向列表中元素。
[root@localhost day4]# cat func.py
#!/usr/bin/env python3 aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse()
print ( "List : ", aList)
[root@localhost day4]# ./func.py
List : ['xyz', 'abc', 'zara', 'xyz', 123]
round() 方法返回浮点数x的四舍五入值。
>>> round(1.3342)
1
>>> round(1.3342,2)
1.33
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。就是切片的功能。
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素 其实相当于 arr[0:4]
[0, 1, 2, 3, 4]
sorted() 函数对所有可迭代的对象进行排序操作
[root@localhost day4]# cat func.py
#!/usr/bin/env python3 a = [50,2,20,1,6,500]
b =sorted(a) # 排列列表
print (a)
print (b) c = {6:2,8:0,1:4,-5:6,99:11,20:50}
d = sorted(c.items()) # 排列字典
print (c)
print (d) [root@localhost day4]# ./func.py
[50, 2, 20, 1, 6, 500]
[1, 2, 6, 20, 50, 500]
{6: 2, 8: 0, 1: 4, -5: 6, 99: 11, 20: 50}
[(-5, 6), (1, 4), (6, 2), (8, 0), (20, 50), (99, 11)]
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
其实就是把2个列表，结合起来一一对应
[root@localhost day4]# cat func.py
#!/usr/bin/env python3 a = [1,2,3,4]
b = ['a','b','c','d'] for i in zip(a,b):
print (i) [root@localhost day4]# ./func.py
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
__import__() 函数用于动态加载类和函数 。
import 能加载模块。
然后当你知道这个模块的字符串的名字是。就是要用_import_(),
最新的python里面感觉和导入模块类似。 和视屏里的有点差别。