Python自学，Day3-Python基础

本节内容

1. 集合操作
2. 文件操作
3. 字符编码与转码
4. 函数基本语法及特性
5. 参数与局部变量
6. 返回值
7. 嵌套函数
8. 递归
9. 匿名函数
10. 函数式编程介绍
11. 高阶函数
12. 内置函数

1、集合　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 

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

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

常见操作

• 定义集合

#创建一个数值集合
num=set([1,2,3,4])
print("1:",num)

#创建一个唯一字符的集合
str=set("hello")
print("2:",str) #按无重复的字母单独拆开

#数值和字符多种形式
name=set(["ace",1,3,5])
print("3:",name)

#输出结果
1: {1, 2, 3, 4}
2: {'l', 'e', 'o', 'h'}
3: {3, 1, 'ace', 5}

• 关系测试

num=set([1,2,3,4])
name=set(["ace",1,3,5])
str=set([1,3])

#并集
print("1:",num.union(name)) #关键词表示形式
print("2:",num|name) #运算符表示

#交集
print("3:",num.intersection(name))
print("4:",num&name)

#差集
print("5:",num.difference(name))    #在num中，但不在name中
print("6:",num-name)

#子集
print("7:",str.issubset(name)) #完全包含则为子集
print("8:",str<=name)

#父集
print("8:",name.issuperset(str))
print("9:",name>=str)

#对称差集
print("10:",num.symmetric_difference(name)) #在num或name中，但是不会同时出现在二者中
print("11:",num^name)

#不存在交加
print("12:",num.isdisjoint(name))  #当两者间无交集时，则返回true，否则false

#输出结果
1: {1, 2, 3, 4, 5, 'ace'}
2: {1, 2, 3, 4, 5, 'ace'}
3: {1, 3}
4: {1, 3}
5: {2, 4}
6: {2, 4}
7: True
8: True
8: True
9: True
10: {2, 4, 5, 'ace'}
11: {2, 4, 5, 'ace'}
12: False

• 增删改

num=set([1,2,3,4])
name=set(["ace",1,3,5])
str=set([1,3])

#添加单项
num.add(5)
print("1:",num)

#添加多项
str.update(["shang",2,4])
print("2:",str)

#删除指定项
name.remove(1) #当删除项不存在时，会报错
print("3:",name)

#随机删除，并将删除项输出
print("4:",name.pop())

#删除指定项
name.discard(3) #当但删除项不存在时，程序不处理
print("5:",name)

#输出结果
1: {1, 2, 3, 4, 5}
2: {1, 2, 3, 4, 'shang'}
3: {'ace', 3, 5}
4: ace
5: {5}

2、文件操作　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

对文件操作流程

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

• 创建文件

先创建file文件，格式为Text，在Text文件中添加内容

文件：over_the_sea

内容：为你我用了半年的积蓄

漂洋过海来看你
为了这次相聚
连见面时的呼吸
都曾反复练习

• 读取文件

f=open("over_the_sea",'r',encoding="utf-8") #需要转化成utf－8
data=f.read() #文件句柄
print(data)

#输出结果
为你我用了半年的积蓄
漂洋过海来看你
为了这次相聚
连见面时的呼吸
都曾反复练习

备注：

打开文件的操作：open("文件名",'模式',encoding="转移字符格式")

r为只读模式，为默认模式，可以不定义;

f.read()为文件的读取

　　当多次读取时

f=open("over_the_sea",'r',encoding="utf-8") #需要转化成utf－8
data=f.read() #文件句柄
print(data)
data2=f.read()
print('－－－－－－－－－data2－－－－－－－－－',data2)

#输出结果
为你我用了半年的积蓄
漂洋过海来看你
为了这次相聚
连见面时的呼吸
都曾反复练习
－－－－－－－－－data2－－－－－－－－－ 

备注：从输出结果可以看出，data2无内容；

因read的模式为影响到读取文件的指针（可类比C语言中的指针），data读取完成后，指针到文件的最后位置，data2进行read时，后续无内容，所以data2无数据

• 写文件

f=open("across_the_ocean_to_meet_you",'w',encoding="utf-8") #需要转化成utf－8
f.write("To meet you I’ve saved every penny\n"
        "To travel far across the sea\n"
        "To be free-and-easy\n"
        "Many times I rehearsed the meet\n"
        "Hoped to impress you deep\n"
        )

结果：新增across_the_ocean_to_meet_you文件，文件内容为write中到内容；

文件内容：

To meet you I’ve saved every penny
To travel far across the sea
To be free-and-easy
Many times I rehearsed the meet
Hoped to impress you deep

写入的内容，以行为区分，换行时需用""来新定义文本内容

因w只是写的模式，不能读取；需注意，w的模式时新创建文件，当文件名已存在时，则会将原文件覆盖

• 追加写文件（append）

f=open("across_the_ocean_to_meet_you",'a',encoding="utf-8")
data=f.write("Words said never convey what I wanted to say\n"
            "What in my mind so clearly\n")


#文件内容
To meet you I’ve saved every penny
To travel far across the sea
To be free-and-easy
Many times I rehearsed the meet
Hoped to impress you deep
Words said never convey what I wanted to say
What in my mind so clearly

备注：模式a，为在原文件的基础上追加内容，当不存在指定文件时，则会同w模式一样创建原文件，并追加内容

• 按行读取

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")

print(f.readlines())    #按行进行全部读取，并输出打印

#输出结果
['To meet you I’ve saved every penny\n', 'To travel far across the sea\n', 'To be free-and-easy\n', 'Many times I rehearsed the meet\n', 'Hoped to impress you deep\n', 'Words said never convey what I wanted to say\n', 'What in my mind so clearly\n']

备注：输出结果为列表

　　打印前5行

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")

#打印前5行
for line in range(5):
    print(f.readline())#readline为按行读取

#输出结果
To meet you I’ve saved every penny

To travel far across the sea

To be free-and-easy

Many times I rehearsed the meet

Hoped to impress you deep

　　按行打印全部行

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")

for line in f.readlines():
    print(line)

#输出结果

To meet you I’ve saved every penny

To travel far across the sea

To be free-and-easy

Many times I rehearsed the meet

Hoped to impress you deep

Words said never convey what I wanted to say

What in my mind so clearly

备注：readlines为按行读取后的列表，通过循环列表来按行打印

　　优化：因文件中有回车，所以输出结果中有空格，去掉空格，使用strip()

print(line.strip())

　　第四行不打印

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")
data=f.readlines()
for line in data:
    if data.index(line)==3:
        print("------我是分隔符------")
        continue
    print(data.index(line),line.strip())

#输出结果
0 To meet you I’ve saved every penny
1 To travel far across the sea
2 To be free-and-easy
------我是分隔符------
4 Hoped to impress you deep
5 Words said never convey what I wanted to say
6 What in my mind so clearly

　　另外一种操作

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")

for index,line in enumerate(f.readlines()): #enumerate获取下标
    if index==3:
        print("------我是分隔符------")
        continue
    print(index,line.strip())

备注：输出结果与上一种方法相同

　　readlines的缺点：一次性将文件的内容全部读取到内存中，若文件量太大，会造成内存占用过高

　　改进方法：读取一行打印之后，读取下一行内容，将上一行内容覆盖，所以以上方法尽量不用

　　高效的循环方法

f=open("across_the_ocean_to_meet_you",'r',encoding="utf-8")

count=0 #用于记录打印行数
for line in f:
    if count==3:
        print("------我是分隔符------")
        count+=1
        continue
    print(line.strip())
    count+=1


#输出结果
To meet you I’ve saved every penny
To travel far across the sea
To be free-and-easy
------我是分隔符------
Hoped to impress you deep
Words said never convey what I wanted to say
What in my mind so clearly

　　备注：该方法为一行一行读取，且后一行内容会覆盖前一行内容

• tell()  当前read的指针所在的位置
• seek()  设置指针所在的位置

　　over_the_sea的文件内容

To meetyou I have saved every penny
To travel far across the sea
To be free-and-easy
Many times I rehearsed the meet

f=open("over_the_sea",'r',encoding="utf-8") #需要转化成utf－8
data=f.readline() #文件句柄
print(data.strip())
print(f.tell()) #获取当前指针的位置
f.seek(0)   #将指针指向最初始0的位置
print(f.readline())

#输出结果
To meetyou I have saved every penny
36
To meetyou I have saved every penny

备注：tell()是按照一个字符为一个位置设定，所以打印的为“36”

• flush　　

　　用来将写入缓存的内容强制写入磁盘中

import sys,time

for i in range(20):
    sys.stdout.write("#")   #屏幕作为终端输出
    sys.stdout.flush()  #强制刷新到磁盘
    time.sleep(0.1) #睡眠0.1秒

#输出结果
 ####################

#备注:依次输出#

• truncate  截断

f=open("across_the_ocean_to_meet_you",'a',encoding="utf-8")

f.truncate(10) 

　　从第一个字符开始，到第10个字符进行截断

　　截断之后文件内容

To meet yo

• r+ 读写（读和追加的模式）

f=open("across_the_ocean_to_meet_you",'r+',encoding="utf-8") #r+的模式

print(f.readline().strip())
print(f.readline().strip())
print(f.readline().strip())
f.write("------第四行追加-------")
print("-------分隔符---------")
print(f.read())

#输出结果
To meet you I’ve saved every penny
To travel far across the sea
To be free-and-easy
-------分隔符---------
Many times I rehearsed the meet
Hoped to impress you deep
Words said never convey what I wanted to say
What in my mind so clearly------第四行追加-------

备注:及时打印为前三行之后，指针在第四行，但是执行write的操作时，却从最后开始追加

• w+ 写读（先创建文件，然后可进行读和写的操作－使用场景不多）

f=open("across_the_ocean_to_meet_you",'w+',encoding="utf-8") #r+的模式

print(f.readline().strip())
print(f.readline().strip())
print(f.readline().strip())
f.write("------第四行追加-------")
print("-------分隔符---------")
print(f.read())

#输出结果



-------分隔符---------
28

备注：1个汉字相当于5个字符，所以输出字符为28；因先进行创建文件，所以前三个读都为空；执行完写之后，指针在最后位置，所以最后读取的内容也为空

•  a+ 追加读写

f=open("across_the_ocean_to_meet_you",'a+',encoding="utf-8") #r+的模式

print(f.readline().strip())
print(f.readline().strip())
print(f.readline().strip())
f.write("\n------我是添加项-------")
print("-------分隔符---------")
f.seek(0)
print(f.read())

#输出结果



-------分隔符---------
To meet you I’ve saved every penny
To travel far across the sea
To be free-and-easy
Many times I rehearsed the meet
Hoped to impress you deep
Words said never convey what I wanted to say
What in my mind so clearly
------我是添加项-------

备注：追加读写，是将指针直接定位在最后，所以前三行读取的内容为空；追加内容添加在最后，添加完之后，指针也在最后；此时将指针的位置设定为0的位置，可以读取整个文件

•  修改文件内容

要求：修改文件中的指定信息，并将信息保存至新文件中

#需求：修改文件中信息，并将信息保存至新文件中

f=open("across_the_ocean_to_meet_you","r",encoding="utf-8")
f_new=open("across_the_ocean_to_meet_you.bak","w",encoding="utf-8")#创建新文件

for line in f:
    if "across the sea" in line:
        line=line.replace("across the sea","across the ocean") #使用字符串修改
    f_new.write(line) #不管是否是需要更新的文件，都是将line更新至至新文件

采用的使逐行读取校验，如果不是需要更改的内容项，则直接更新至新文件，如果是需要更改的内容项，则使用字符替换，然后再写入新的文件中

• with操作

正常情况下，在打开文件操作后，需关闭该文件，关闭语句为：f.close()；通常在程序执行完之后，python会自动给关闭打开的文件

但是会存在忘记关闭的情况，尤其在程序执行时，可能会同时打开多个文件，以及大量暂用内存；

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

with open("文件名","r",encoding="utf-8") as f:
    ...
    ...
    ...

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

以修改文件内容的场景为例：

with open("across_the_ocean_to_meet_you","r",encoding="utf-8") as f ,\
     open("across_the_ocean_to_meet_you.bak","w",encoding="utf-8") as f_new:
    for line in f:
        if "across the sea" in line:
            line = line.replace("across the sea", "across the ocean")  # 使用字符串修改
        f_new.write(line)

• 总结

　　打开文件的模式有：

• r ，只读模式【默认】
• w，只写模式【不可读；不存在则创建；存在则清空内容；】
• x， 只写模式【不可读；不存在则创建，存在则报错】
• a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

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

• r+， 读写【可读，可写】
• w+，写读【可读，可写】
• x+ ，写读【可读，可写】
• a+， 写读【可读，可写】

 "b"表示以字节的方式操作

• rb  或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+b

 注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

 3、字符编码及转码　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

 

详细文章:

 

http://www.cnblogs.com/yuanchenqi/articles/5956943.html

 

http://www.diveintopython3.net/strings.html

yy:找时间在看吧，先抓重点快速前进....

 

需知:

1.在python2默认编码是ASCII, python3里默认是unicode

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间

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

　　decode()　编码成unicode

　　encode()　解码成utf-8，或者gbk

#-*-coding:gbk-*-
#声明文件的编码格式为gbk
#备注：文件格式调整为GBK的模式

import sys
print(sys.getdefaultencoding()) #系统默认的编码还是utf－8


s="你好" #仍然为utf-8
print(s)
print(s.encode("gbk")) #显示的是gbk的编码格式
print(s.encode("utf-8"))
print(s.encode("utf-8").decode("utf-8"))
print(s.encode("gb2312"))#gbk向下兼容gb2312
print(s.encode("gb2312").decode("gb2312"))

 4、函数与函数式编程　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　python定义函数

　　def 函数名(参数):

　　　　"文档描述"

　　　　函数体逻辑

　　　　return 参数

#函数式编程
def fun(x):
    '''自增函数'''
    x+=1
    print(x)
    return x

#面向过程(无返回值的函数)
def fun2(x):
    '''过程'''
    print(x)

x=fun(1)
y=fun2(1)

print("x:",x) #x有具体的返回值
print("y:",y) #y返回为none


#输出结果
2
1
x: 2
y: None

 函数例子：

import time

def logger(): #打印log日志
    time_format='%Y-%m-%d %X' #定义时间格式
    time_current=time.strftime(time_format) #获取当前时间
    with open("log.txt","a+") as f:
        f.write("%s error.log\n" %time_current)


def test1():
    print("in the test1")
    logger()

def test2():
    print("in the test2")
    logger()

def test3():
    print("in the test3")
    logger()

test1()
test2()
test3()

#输出结果
in the test1
in the test2
in the test3


#log.txt文件内容
2018-08-16 07:01:02 error.log
2018-08-16 07:01:02 error.log
2018-08-16 07:01:02 error.log

使用函数的优点总结：

1、代码重用

2、保持一致性

3、可扩展性

• 返回值return

def test1():
    print("in the test1")

def test2():
    print("in the test2")
    return 0

def test3():
    print("in the test3")
    return 1,'hello',['shang','quan'],{'shang','quan'}

x=test1() #x用来接收返回值
y=test2()
z=test3()

print(x)    #返回none
print(y)    #返回0
print(z)    #返回元组


#输出结果
in the test1
in the test2
in the test3
None
0
(1, 'hello', ['shang', 'quan'], {'shang', 'quan'})

总结：

返回值个数＝0，none

返回值个数＝1，定义的内容

返回值个数>1，元组

• 参数定义

def test(x,y): #x、y为形参
    print(x)
    print(y)

test(1,2) #1,2为实参(位置参数)
test(y='A',x='B') #关键字调用
test(5,y=7) #关键字一定不可以放在位置参数前

#输出结果
1
2
B
A
5
7

　　默认参数

 　　调用函数时，使用默认函数

def test(x,y=2):
    print(x)
    print(y)


test(1)
test(1,3)
test(1,y=4)

#输出结果
1
2
1
3
1
4

默认阐述特点：调用函数的时候，默认参数非必须传递

用途：软件默认安装、数据库端口号等

　　参数组

当实参不固定时，需使用参数组传递

def test(x,*args):  #
    print(x)
    print(args)

test(1,2,3,4,5)

#输出结果
1
(2, 3, 4, 5)

不固定参数，使用*args传递，将接收到的参数转化成元组的方式

备注：*args是用来接受N个位置参数

 字典的方式

#字典  把N个关键字参数，转换成字典的方式
def test2(**kwargs):
    print(kwargs)

test2(names='shang',age=29,sex='M')

def test3(name,**kwargs):
    print(name)
    print(kwargs)

test3('shang',age=29,sex='M')

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

test4('shang',sex='M',hobby='Make Money')


#输出结果
{'names': 'shang', 'age': 29, 'sex': 'M'}
shang
{'age': 29, 'sex': 'M'}
shang
19
{'sex': 'M', 'hobby': 'Make Money'}

组合的方式

def test1(name,age=19,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)

test1('shang',29,'ace','python',10,sex='M',hobby='Make Money')


#输出结果
shang
29
('ace', 'python', 10)
{'sex': 'M', 'hobby': 'Make Money'}

备注：位置参数传递给*args，如果没有对应的位置参数，则args为空元组；关键字传递给**kwargs

• 局部变量

定义在函数中，该函数是局部变量的作用域

def chang_name(name):
    print("before_name",name)
    name='ace'  #局部变量，只在函数中生效
    print("after_name",name)


name='shang'
chang_name(name)
print(name)

#result
before_name shang
after_name ace
shang

• 全局变量

在整个程序中都生效的变量，定义在程序的顶部部分

name='shang'  #全局变量
age=29 #全局变量

def chang_name(name):
    global age  #声明全局变量
    age = 30  # 修改全局变量
    print("before_name",name)
    name='ace'  #局部变量，只在函数中生效
    print("after_name",name)

chang_name(name)
print(name)
print(age)

#result
before_name shang
after_name ace
shang
30

备注：全局变量理论上是不可以修改的，但是如果需要修改的场景，则需在函数中先声明全局变量global，然后就可以改动全局变量；

同时，不可在函数中用global定义全局变量，不符合书写规范

需注意：

当全局变量为：列表、字典、集合时，函数可以直接修改全局变量

resume=['shang',29,'pm']

def change_resume():
    resume[1]=30 #函数中可以直接修改列表、字典、集合和类的全局变量中的参数
    
change_resume()
print(resume)

#result
['shang', 30, 'pm']

• 递归

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

递归特征：

1、必须要有明确的结束条件

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

3、递归效率不高，递归层次过多会导致栈溢出

def calc(n):
    print(n)
    n=int(n)
    if n > 1:
        return calc(n/2)

n=input('input the number')
calc(n)

#result
input the number45
45
22.5
11.0
5.5
2.5
1.0

•  高阶函数

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

def sum(x,y,func):
    return func(x)+func(y)

add=sum(3,-1,abs)   #将绝对值函数abs传递给func
print(add)

#result
4