码迷,mamicode.com
首页 > 编程语言 > 详细

Python学习week3

时间:2018-09-17 21:31:18      阅读:270      评论:0      收藏:0      [点我收藏+]

标签:exist   first   import   默认   log   字典   用法   remove   集合   

集合:去重,关系测试,无序存放

lis=[1,3,3,5,9,7]
lis=set(lis)
lis2=set([0,1,3,5,4,2])
print(lis,lis2)
print(lis.intersection(lis2))       #交集
print(lis.union(lis2))      #并集
print(lis.difference(lis2))     #差集  lis中除去lis2元素剩余的元素
print(lis.symmetric_difference(lis2))   #对称差集,返回两个集合中不重复的元素的新集合
lis3={1,3,5}
print(lis3.issubset(lis2))       #判断是否子集,返回True或者False
print(lis.issuperset(lis2))       #判断是否父集,返回True或者False
print(lis.isdisjoint(lis2))     #判断两个集合是否没有交集

集合运算符:

print(lis&lis2)     #交集
print(lis|lis2)     #并集
print(lis-lis2)     #差集
print(lis^lis2)     #对称差集
print(lis3<=lis)    #判断是否是子集
print(lis>=lis3)    #判断是否是父集

集合元素的增删:

print(len(lis))     #长度
print(1 in lis)     #判断元素是否在集合中
lis.add(999)        #增加一个元素
lis.update([10,100,200])      #增加多个元素
lis.remove(100)     #删除一个元素,元素必须包含在集合中,否则报错
lis.discard(101)        #如果集合包含此元素则删除,不包含时do nothing.
print(lis.pop())        #随机删除一个元素并返回

 


 

文件操作:打开文件,操作文件,关闭文件

 

f=open(‘quietnight‘,encoding=‘utf-8‘)    #默认读操作
f.close()

 为了防止忘记关闭文件,使用with语句:

with open(‘quietnight‘,‘r‘,encoding=‘utf-8‘)as f:    #等效于:f=open(‘quietnight‘,‘r‘,encoding=‘utf-8‘)
    print(f.readline())
    print(f.closed)
print(f.closed)
输出:
床前明月光,

False
True

 在with语句内打开文件,with语句结束时文件关闭。

 with可以同时打开多个文件:

with open(‘quietnight‘,‘r‘,encoding=‘utf-8‘)as f1,open(‘quietnight2‘,‘r‘,encoding=‘utf-8‘)as f2:

 

with open(‘quietnight‘,‘r‘,encoding=‘utf-8‘)as f1,        open(‘quietnight2‘,‘r‘,encoding=‘utf-8‘)as f2:

 

 f称为文件句柄,是文件映射在内存中的对象,用来执行对文件的操作

 

读文件:

f=open(‘quietnight‘,encoding=‘utf-8‘)
data=f.read()
data2=f.read()
print(data)
print(data2)

 

 data2为空,f包含文件在硬盘里的起始位置,当使用第一个data=f.read()时,f读取文件并把文件内容赋值给data,此时f指向文件末尾处,所以第二次read读取的内容为空。

读取前3行

for i in range(3):
    print(f.readline())

读取3-6行:

f=open(‘quietnight‘,encoding=‘utf-8‘)
for i in range(6):
    if i>1:      #i=2时开始打印,是从第三行开始的
        print(f.readline().strip())
    else:
        f.readline()

 readline()每次读取一行。

 readlines()把文件内容每行当成一个元素,形成列表。

 

f=open(‘quietnight‘,encoding=‘utf-8‘)
print(f.readlines())

 

 输出:

[‘床前明月光,\n‘, ‘疑是地上霜。\n‘, ‘举头望明月,\n‘, ‘低头思故乡。‘]

 循环输出(效率低下):

f=open(‘quietnight‘,encoding=‘utf-8‘)
for line in f.readlines():
print(line.strip())    #如果不加strip(),每个line元素的结尾处有\n换行,输出会隔一行

  输出:

床前明月光,
疑是地上霜。
举头望明月,
低头思故乡。
f=open(‘quietnight‘,encoding=‘utf-8‘)
for line in f.readlines():
    print(line)

输出结果(隔行输出): 床前明月光, 疑是地上霜。 举头望明月, 低头思故乡。

 第3行不输出:

技术分享图片
1 f=open(quietnight,encoding=utf-8)
2 for index,line in enumerate(f.readlines()):
3     if index==2:
4         print(-----分割线-----)
5         continue
6     print(line.strip())
View Code

 输出结果:

床前明月光,
疑是地上霜。
-----分割线-----
低头思故乡。

enumerate(list)可以用于for循环,每次获取列表元素的index和元素本身。

技术分享图片
1 lis=[0,2,4,6,8]
2 for i in enumerate(lis):
3     print(i)
4 输出:
5 (0, 0)
6 (1, 2)
7 (2, 4)
8 (3, 6)
9 (4, 8)
View Code
技术分享图片
1 lis=[0,2,4,6,8]
2 for i,j in enumerate(lis):
3     print(i,j)
4 输出:
5 0 0
6 1 2
7 2 4
8 3 6
9 4 8
View Code

使用readlines方法读取文件,程序会把硬盘上的文件内容全部读取到内存中,速度慢并且浪费资源。

高效读取文件的方法:

 

f=open(‘quietnight‘,encoding=‘utf-8‘)
for i in f:    #f不再是列表,内存读取一行打印后就释放
    print(i)

 


 

写文件:

f=open(‘quietnight‘,‘a‘,encoding=‘utf-8‘)
f.write(‘\n春江花月夜‘)

 ‘a’代表以写的操作方式打开文件,如果‘quietnight‘文件不存在则创建并写入内容,存在时把要写的内容加入到文件末尾处。

f=open(‘quietnight‘,‘w‘,encoding=‘utf-8‘)
f.write(‘\n春江花月夜‘)

 ‘w’也是写操作,如果‘quietnight‘文件不存在则创建并写入内容,如果存在则覆盖原内容。相当于创建新文件。

 

f.write(‘\n春江花月夜‘)把要写的内容加入到文件末尾处。

 

技术分享图片
1 r       open for reading (default)
2     w       open for writing, truncating the file first
3     x       create a new file and open it for writing
4     a       open for writing, appending to the end of the file if it exists
5     b       binary mode
6     t       text mode (default)
7     +       open a disk file for updating (reading and writing)
8     U       universal newline mode (deprecated)
View Code

 

其他文件操作方法:

 

技术分享图片
1 f=open(quietnight,r,encoding=utf-8)
2 print(f.tell())     #输出当前光标位置
3 print(f.read(5))        #读五个字符
4 print(f.tell())     #utf-8编码方式下,一个汉字占三个字节,所以输出为15。(0+15)
5 f.seek(0)       #用于将f光标重新定位,f.seek(0)是把光标移到初始位置
6 print(f.encoding)       #编码方式,注意encoding后面没有括号,encoding是f的参数,没有括号,方法才有括号
7 print(f.fileno())       #python调用操作系统的IO接口来打开文件,接口同时为python和其他程序打开文件,fileon()方法返回当前文件编号
8 print(f.seekable())     #判断当前文件是否可以移动光标,某些设备文件不能移动光标
9 print(f.closed)     #判断文件是否已经关闭
View Code

 

f=open(‘quietnight‘,‘a‘,encoding=‘utf-8‘)
f.truncate(20)

 截取保留文件的前20个字节,无论光标f位置在哪,都从文件起始位置截取

 

f.flush()

 文件读写具有缓存机制,默认内存到缓存再到硬盘。缓存满了后一次性存储到硬盘,并非逐行从内存到硬盘。flush()方法用于强制把文件内容从内存实时存储到硬盘。

可以用来实现进度条功能:

import sys,time
for i in range(10):
    sys.stdout.write(*)       #打印‘*’后不换行,print()会默认换行
    sys.stdout.flush()      #flush()使得‘*’立即输出打印,不会保存在缓冲区
    time.sleep(0.5)     #sleep()用于将程序暂停0.5秒

读写文件:r+

f=open(‘quietnight‘,‘r+‘,encoding=‘utf-8‘)
print(f.readline())
f.write(‘-----分割线-----‘)    #无论光标当前位置在哪,都写在文件末尾处,只有用seek()方法定位光标时,才能写入修改信息。

 写读文件:w+     仍然会把原文件覆盖,相当于创建新文件。

二进制文件格式:rb    网络传输。python3里网络传输只能用二进制。

 


 修改文件内容:创建新文件,把要修改的地方写入新文件

技术分享图片
1 f=open(quietnight,r,encoding=utf-8)
2 f2=open(jingyesi,w,encoding=utf-8)
3 for line in f:
4     if 举头 in line:
5         line=line.replace(举头,举头举头举头)
6     f2.write(line)
7 f.close()
8 f2.close()
修改文件内容

 


 字符编码

 ASCII:英文一个字节,不能存中文

GBK,GB2312:中文编码方式

 unicode:英文、中文都占两个字节,万国码,兼容很多编码,是不同语言编码转换的桥梁。python3默认按照Unicode存储代码。

 utf-8( unicode的扩展集):可变长字符编码,英文字符按照ASCII码存储,中文三个字节存储。

字符编码转码:A语言编码转换为Unicode,再转换为B语言编码。

 


 

 函数:代码重用,可扩展。

程序自上而下执行,在调用函数之前需要先定义。函数体内可以调用其他函数。

 过程:没有返回值的函数

面向过程的编程方法:很多个过程组合成程序。

无返回值时,返回none;

返回数字时,接收数字;

返回多个类型的值时,接收元组。

 

技术分享图片
 1 def test1():
 2     print(in test 1)
 3 def test2():
 4     print(in test 2)
 5     return 0
 6 def test3():
 7     print(in test 3)
 8     return 1,chengdu,(chengdu,sichuan),{sichuan:chengdu}
 9 x=test1()
10 y=test2()
11 z=test3()
12 print(x)
13 print(y)
14 print(z)
15 
16 输出:
17 in test 1
18 in test 2
19 in test 3
20 None
21 0
22 (1, chengdu, (chengdu, sichuan), {sichuan: chengdu})    #元组
不同返回值的函数

 

含参函数的调用:

def test(x,y,z):
    print(x,y,z)
test(1,2,3)      #位置调用
test(y=5,x=4,z=6)       #关键字调用
test(7,z=8,y=9)       #混合调用

 test(1,y=2,3)    报错关键字调用不能在位置调用之前

默认参数:

def test(x,y,z=3):
    print(x,y,z)
test(1,2)

 

 参数组1:把多个位置参数转变为元组一个*,参数名一般用args

def test(*args):    #形参名是args,*是功能代号
    print(args)
test(1,2,3)
test(*[1,2,3])    #*args=*[1,2,3] -->args=[1,2,3],输出变成元组,忘记这种用法
输出元组:
(1, 2, 3)
(1, 2, 3)

 混合参数1:位置参数+参数组,参数组写在最后

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

混合参数2:默认参数+参数组,默认参数可以放在参数组之后。

def test(*args,a=111):
    print(a,args)
test(1,2,3,4)
输出:
111 (1, 2, 3, 4)

 

参数组2: 把多个关键字参数转变为字典。两个*,参数名一般用kwargs.

两种调用方式如下:

def test2(**kwargs):
print(kwargs)
test2(name=‘刚田武‘,age=22,weight=150)
test2(**{‘name‘:‘刚田武‘,‘age‘:22})    #忘记这种用法
输出:
{‘age‘: 22, ‘name‘: ‘刚田武‘, ‘weight‘: 150}
{‘age‘: 22, ‘name‘: ‘刚田武‘}

  混合参数1:位置参数+参数组

 

def test2(a,**kwargs):
    print(a,kwargs)
test2(‘panghu‘,name=‘刚田武‘,age=22,weight=150)
输出:
panghu {‘name‘: ‘刚田武‘, ‘age‘: 22, ‘weight‘: 150}

 

 混合参数2:位置参数+默认参数+参数组 (参数组只能写在最后)

def test(a,age=18,**kwargs):
    print(a,age,kwargs)
test(‘panghu‘,name=‘刚田武‘,age=22,weight=150)
输出:
panghu 22 {‘weight‘: 150, ‘name‘: ‘刚田武‘}

 混合参数3:位置参数+默认参数+*参数组+**参数组

 

def test(a,age=18,*args,**kwargs):
    print(a)
    print(age)
    print(args)
    print(kwargs)
test(‘panghu‘,name=‘刚田武‘,age=22,weight=150)
输出:
panghu
22
()
{‘weight‘: 150, ‘name‘: ‘刚田武‘}

 


 

全局变量与局部变量:

全局变量在程序的最外层定义,作用于整个程序;

局部变量在函数内部定义,只作用于函数。

当全局变量与局部变量同名时:在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。

不要在函数中改变全局变量,更不能在函数中定义全局变量。

字符串和整数不能在函数内修改,但是列表、字典可以在函数内修改。

技术分享图片
Name=gangtianwu       #全局变量
def change(name):       #函数改变不了全局变量
    print("before change:",name)
    name=name.upper()
    print(after change:,name)
change(Name)
print(Name)
输出:
before change: gangtianwu
after change: GANGTIANWU
gangtianwu
全局变量

如果需要在函数内改变全局变量,使用global:如果函数外部有此全局变量则改变,如果没有则创建并当成全局变量,在调用此函数后此全局变量才可以访问。(尽量避免使用global)

技术分享图片
Name=gangtianwu
sex=male
def change(name):
    global sex         #可以改变全局变量sex
    sex=female
    print("before change:",name)
    name=name.upper()
    print(after change:,name)
change(Name)
print(Name)
print(sex)
输出:
before change: gangtianwu
after change: GANGTIANWU
gangtianwu
female    
global

 

递归函数:函数在内部调用自己。

特性:1、必须有明确的结束条件;2、每次进入更深一层递归时,问题规模相比上次递归都应有所减少;3、递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)

(https://www.cnblogs.com/alex3714/articles/5740985.html)

 

技术分享图片
 1 def cal(n):
 2     print(n)
 3     if int(n/2)==0:
 4         return n
 5     return cal(int(n/2))
 6 a=cal(10.5)
 7 输出:
 8 10.5
 9 5
10 2
11 1
递归

 

高阶函数:实参是函数的函数。

Python内置函数:

技术分享图片

 

https://docs.python.org/3/library/functions.html?highlight=built#ascii

 

Python学习week3

标签:exist   first   import   默认   log   字典   用法   remove   集合   

原文地址:https://www.cnblogs.com/zhhy236400/p/9621088.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!