python学习之路-day3

 

本节内容

1.集合操作

2.文件操作

3.字符编码与转码

4.函数

====================================

一、集合操作

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

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

 

1.1定义一个集合

a = set((1,2,3))
print(a)

输出：

{1, 2, 3}

 

• 例

list_1 = [1,2,3,4,5]
list_2 =set(list_1)
print(list_1)

输出：
[1, 2, 3, 4, 5]

2.关系测试

交集（取重）

a = set([1,2,3,4,5])
b = set([3,5])
方法一：
t = a & b
print(t)
方法二：
s = a.intersection(b)
print(s)

输出结果：
{3, 5}
{3, 5}

并集（去重）

 1 a = set([1,2,3,4,5])
 2 b = set([3,5,7,9,10])
 3 方法一：
 4 t = a | b
 5 print(t)
 6 方法二：
 7 s = a.union(b)
 8 print(s)
 9 输出结果：
10 {1, 2, 3, 4, 5, 7, 9, 10}
11 {1, 2, 3, 4, 5, 7, 9, 10}

 差集

a = set([1,2,3,4,5])
b = set([3,5,7,9,10])
方法一：
t = a - b
t2 = b - a
print(t)
print(t2)

方法二：
s = a.difference(b)
s2 = b.difference(a)
print(s)
print(s2)
==================
输出结果：
{1, 2, 4}
{9, 10, 7}
{1, 2, 4}
{9, 10, 7}

子集&父级

a = set([3,5,7])
b = set([1,2,3,4,5,6,7,8])
print(a.issubset(b))     #a是b的子集
print(b.issuperset(a))   #b是a的父集


输出结果：
True
True

对称差集

a = set([3,5,7])
b = set([1,2,3,4,5,6,7,8])
#二种方法
print(a ^ b)
print(a.symmetric_difference(b)
================
输出结果：

{1, 2, 4, 6, 8}
{1, 2, 4, 6, 8}

二、文件操作 

对文件操作流程

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

基础操作

f = open('lyrics') #打开文件

first_line = f.readline()

print('first line:',first_line) #读一行

print('我是分隔线'.center(50,'-'))

data = f.read()# 读取剩下的所有内容,文件大时不要用

print(data) #打印文件

 

f.close() #关闭文件

打开文件模式有：

• 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

 

 现有文件如下:

 

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('test,txt','r')  文件句柄

f = f.readlines()  #将文件全部读出，以列表方式

文件重命名

==============================

import os
os.remove('test.txt')                   #先将原文件删除，否则无法重命名
os.rename('test1.txt','test.txt')       #将新文件重命名为原文件名

==============================
例：文件里面内容替换

import  os
print("文件内容如下：")
with open('test.txt','r',encoding="utf-8") as f:  #只读模式打开文件
    for i in f:
        print(i)                    #将原文件内容打印出来，方便查看需要替换的内容
s = input("请输入你要替换前的内容：")
s2 = input("请输入要替换后的内容：")
f = open('test.txt','r',encoding="utf-8")
with  open('test1.txt','w+',encoding="utf-8") as p:      #以写读模式重新打开文件
    for j in f:                                         #循环文件
        if s in j:                          #判断要替换的内容是否存在于文件中
            j = j.replace(s,s2)             #替换需要替换的内容
        p.write(j)                          #将内容重新写入到文件
f.flush()                               #刷新缓存到硬盘
f.close()                               #关闭文件
os.remove('test.txt')                   #先将原文件删除，否则无法重命名
os.rename('test1.txt','test.txt')       #将新文件重命名为原文件名

with语句

 

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

with open('log','r') as f:

                            pass

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

 

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

with open('log1') as obj1, open('log2') as obj2:

             pass

三、函数

　　1.面向对象

　　2.面向过程   #没有返回值

　　3.函数式编程　　#有返回值（有返回值的面向过程）

1.函数定义

    python中函数定义方法：
     
    def test():
        "The function definitions"
        return 0            #返回值，遇到return就终止运行了
            print (‘123)         #后面的print就不执行了
    x = test()                  #将返回值赋值给x

例一：打印带时间的日志到文件

import time
def logger_test():
    time_format='%Y-%m-%d %X'
    time_current=time.strftime(time_format)
    with open('a.txt','a+) as f:
    f.write('time %s end action' %time_current)  
def test1():
    print 'test1 starting action...'
     
    logger_test()
     
def test2():
    print 'test2 starting action...'
     
    logger_test()
      
def test3():
    print 'test3 starting action...'

2、参数

　　1.　位置参数

def test(x,y):         #x,y位置参数，下面传参的时候要一一对应，不可多，也不可少
    print(x)
    print(y)
test(1,2)         #1,2实际存在于内存中，是实参，x和y为形参

　　2.关键参数

def test(x,y,z):
    print(x)  
    print(y)
    print(z)
test(z=1,x=2,y=3)       #x,y,z为关键参数，不用一一对应

　　例：

def test(x,y,z):
    print(x)  
    print(y)
    print(z)
test(1,2,z=3)     #1,2是位置参数，z=3是关键参数，关键参数只能放置在位置参数后面

 

　　3.默认参数

def test(x,y=2):        #y = 2是默认参数
    print(x)
    print(y)
test(1)                #y有默认参数，所以可以不用传参
test(1,3)                #实际参数大于默认参数
test(1,y=4)              #大于默认参数

　　4.参数组

def test(*alex)     #alex是形参
    print(alex)
def test1(x,*args)    #规范就是args，*args接受位置参数，转换成元组的方式
    print(x)
    print(args)
test(1,2,3,4,5)            #实参可以任意数量
test1(1,2,3,4,5)        #1传给x，2，3,4,5，传给args

**kwargs参数组

把所有关键参数转换成字典，接受关键字参数
def test(**kwargs):
    print(kwargs)
test(name = 'lw',age='25')
输出：{'age': '25', 'name': 'lw'}
----------------------------------------------------
def test2(name,**kwargs):
    print(name)
    print(kwargs)
test2('lw')
输出：
lw
{}
-------------------------------------------------------
def test3(name,age=10,**kwargs):
    print( name)
    print(age)
    print(kwargs)
test3('lw',sex='M',hobby='tesla')
输出：
lw
10
{'hobby': 'tesla', 'sex': 'M'}
----------------------------------------------------------

四、局部变量

例：

 

def change_name(name):
    print("before change",name)
    name = "LW"             #局部变量，只在此函数中生效，像列表，字典，集合等可以在全局神效（只有字符串和整数之类的只在函数生效）
    print("after change",name)
name = "lw"
change_name(name)
print(name)
输出：
before change lw
after change LW
lw

五、全局变量

school  == ‘oldboy’
def change_name(name):
    school = 'MG'
    print("before change",school)
change_name('lw')
print(school)

在函数里面定义全局变量：global school = 'MG'
不要在函数里面改（定义）全部变量

六、递归

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

递归特性：

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

例一、

 

def calc(n):
    print(n)
    if int(n/2)>0:
        return calc(int(n/2))
    print('--->',n)
calc(20)