python笔记四

Posted 2020-10-31 xmhd

今天继续学习Python，修改文件。

一，往文件里面添加数据，内存里面有缓冲区，等缓冲区满了再把数据写到磁盘里面。

1 fw = open(‘username‘,‘w‘)
2 fw.write(‘ddd‘)
3 fw.flush()#强制把缓冲区里面的数据写到磁盘上（只有遇到，你写完东西没有立马存到文件里面，那么就是用fw.flush()这个方法）

二,简单粗暴直接修改文件

分析思路：

1,打开一个文件，获取到他的所有内容。
2.对内容进行修改。
3.清空原来文件的内容。
4.把新的内容写进去。

 1 #修改文件内容，把原来的密码‘123’都修改为‘1234’
 2 f=open(‘username‘,‘a+‘,encoding=‘utf-8‘)
 3 f.seek(0)
 4 all_str=f.read()
 5 new_str=all_str.replace(‘123‘,‘1234‘)
 6 f.seek(0)
 7 f.truncate()#清空文件内容
 8 f.write(new_str)
 9 f.close()
10 
11 #下面这个方法是给用户名增加一个前缀
12 f=open(‘username‘,‘a+‘,encoding=‘utf-8‘)
13 f.seek(0)
14 all_str=‘‘
15 for line in f:
16     i=‘syz‘+line
17     all_str=all_str+i
18 f.seek(0)
19 f.truncate()
20 f.write(all_str)
21 f.close()
22 
23 f.write()#写的时候只能写字符串
24 f.writelines([‘a‘,‘b‘])#可以直接把list写进文件（因为他能帮助我们循环）

（B）快速修改文件，通过两个文件进行修改

 1 # 打开2个文件
 2 # a文件
 3 # 写一行写到b文件
 4 # a.txt  a.txt.bak
 5 #删掉a文件，b文件名字改为a文件名
 6 import os
 7 with open(‘words‘,encoding=‘utf-8‘) as fr,open(‘.words.bak‘,‘w‘,encoding=‘utf-8‘) as fw:
 8     for line in fr:
 9         new_line = line.replace(‘花‘,‘flower‘)
10         fw.write(new_line)
11 os.remove(‘words‘)#删除文件
12 os.rename(‘.words.bak‘,‘words‘)#修改文件名

三,函数。

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

四，使用函数的好处

1、简化代码
2、提高代码的复用性
3、代码可扩展

五。python中函数的定义：

定义函数使用def关键字，后面是函数名，函数名不能重复

简单的定一个函数：

1 def sayHello():#函数名
2     print(‘hello‘)#函数体
3 
4 #函数不调用是不会被执行的
5 # sayHello()#调用函数

六，函数的参数（实参，形参）

函数在调用的时候，可以传入参数，有形参和实参

形参：

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。

实参：

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

 

#函数的参数
def calc(a,b):#形参，形式参数
    #位置参数，必填参数
    res=a*b
    print(‘%d*%d=%d‘%(a,b,res))

# calc(2,5)#实参，实际参数

简单点说，形参就是函数接收的参数，而实参就是你实际传入的参数。

函数的四种形参类型：

位置参数：

位置参数，字面意思也就是按照参数的位置来进行传参，比如说上面的calc函数，x和y就是位置参数，位置参数是必传的，

有几个位置参数在调用的时候就要传几个，否则就会报错了，那如果有多个位置参数的话，记不住哪个位置传哪个了怎么办，可以使用位置参数的名字来指定调用

比如说上面的那个calc函数也可以使用calc(y=1,x=2)这样来调用，这种调用方式叫做关键字传参

七，默认参数值：

def op_file(file_name,content=None):
    #默认值参数(content=None),他是非必填的
    f=open(file_name,‘a+‘,encoding=‘utf-8‘)
    f.seek(0)
    if content:#不为空代表写
        f.write(content)
        f.flush()
    else:
        all_user=f.read()
        return all_user  #调用完函数之后，返回什么结果
    f.close()


op_file(‘a.txt‘,‘admin‘)
res =op_file(‘a.txt‘)#通过res来接收返回的参数值
print(res)

八，return返回值

def hah():
    # 函数里面遇到return，函数就立即结束了
    for i in range(5):
        print(i)
        if i==3:
            return #直接一个return的话，就返回None
hah()

#return
# 1.把函数处理的结果返回来。
# 2.结束函数。

每个函数都有返回值，如果没有在函数里面指定返回值的话，在python里面函数执行完之后，默认会返回一个None，函数也可以有多个返回值，如果有多个返回值的话，会把返回值都放到一个元组中，返回的是一个元组。

为什么要有返回值呢，是因为在这个函数操作完之后，它的结果在后面的程序里面需要用到。

函数中的返回值使用return，函数在遇到return就立即结束。

如下两个小练习：

练习一：

import string
def check(pwd):
    #长度是6-11，必须包含字母和数字
    if len(pwd)>5 and len(pwd)<12:
        if set(pwd)&set(string.ascii_letters)and set(pwd)&set(string.digits):
            print(‘密码合法‘)
        else:
            print(‘密码不合法‘)
    else:
        print(‘密码长度不合法‘)

res=check(‘1234asd‘)#函数里面如果没有return的话，默认返回None
print(res)

练习二：

 1 练习二：
 2 # 合法的小数  return true
 3 # 不合法，return false
 4 # 分析需求：
 5 # 1.小数点个数.count()
 6 # 2.按照小数点进行分割 1.98 【1.98】
 7 # 3.正小数：小数点左边是整数，右边也是整数。 isdigits()
 8 # 4.负小数：小数点左边是以负号开头，右边也是整数，但是只有一个负号
 9 def isfloat(f):
10     s = str(f)
11     if s.count(‘.‘)==1:
12         s_list=s.split(‘.‘)
13         l = s_list[0]
14         r = s_list[1]
15         if l.isdigit() and r.isdigit():#正整数
16             return True
17         elif l.startswith(‘-‘) and l.count(‘-‘)==1:#判断是否有可能是合法的负数
18             if l.split(‘-‘)[1].isdigit() and r.isdigit():
19                 return True
20     return False
21 
22 print(isfloat(1.92))
23 print(isfloat(-1.23))
24 print(isfloat(-1))
25 print(isfloat(123))
26 print(isfloat(‘s.98‘))
27 print(isfloat(‘1.2w‘))
28 print(isfloat(‘--2.23‘))
29 print(isfloat(‘-1.-23‘))
30 print(isfloat(1.0))

九，全部变量与局部变量

1、局部变量意思就是在局部生效的，出了这个变量的作用域，这个变量就失效了，比如上面的c就是一个局部变量，出了这个函数之后，就没有c这个值了

2.全局变量的意思就是在整个程序里面都生效的，在程序最前面定义的都是全局变量，全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改。

 1 name = ‘张三‘
 2 #全局变量
 3 # 如果要改全局变量的话，那你要先声明一下，你修改值是全局变量
 4 # 1.不安全，因为所有人都可以改。
 5 # 2.全局变量占内存，不会释放内存，局部变量会释放内存
 6 def syaName():
 7     global  name #商量修改全局变量
 8     name = ‘李四‘
 9     print(‘name1‘,name)
10 def setName():
11     global name
12     name = ‘花花‘
13 syaName()
14 setName()
15 print(‘name2‘,name)
16 print(‘name3‘,name)
17 
18 #下面的练习是传参
19 def op_mysql(host,port,username,password,db,charset,sql):
20 
21 op_mysql(sql=‘select * from user;‘,
22          host=‘192.168.174.128‘,
23          username=‘admin‘,
24          password=‘123456‘,
25          db=‘test‘,
26          port=‘xx‘,
27          charset=‘xxx‘)

十，递归调用：就是自己调用自己

 1 #递归，自己调用自己
 2 # def test1():
 3 #     num = int(input(‘please enter a number：‘))
 4 #     if num%2==0:#判断输入的数字是不是偶数
 5 #        return True #如果是偶数的话，程序就退出了，返回true
 6 #     print(‘不是偶数请重新输入！‘)
 7 #     return test1()#如果不是偶数的话继续调用自己，输入值
 8 # print(test1())#调用test
 9 #少用递归，递归最多递归999，递归的效率不高。
10 
11 i=0
12 def test():
13     global i
14     i+=1
15     print(i)
16     test()
17 print(test())

递归调用的特性：

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

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

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

十一，内置函数

 1 # #内置函数：
 2 # Python自带的一些函数，直接拿过来能用的
 3 # id()#看内存地址
 4 # type()#看数据类型
 5 # print()#打印
 6 # input()#输入
 7 # list()#转list
 8 # set()#转集合
 9 # str()#转字符串
10 # dict()# 转字典
11 # int()#转int
12 # float()#转float
13 # len()#取长度
14 # max()
15 # min()
16 # dir()#帮助看有哪些函数可用
17 # sorted()#排序
18 # round(11.23,2)#保留几位小数
22 
23 
24 print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真
25 print(any([0,1,2,3,4]))#判断可迭代的对象里面的值是否有一个为真
26 print(bin(10))#十进制转二进制
27 print(bool(‘s‘))#把一个对象转换成布尔类型
28 print(chr(10))#打印数字对应的ascii
29 print(ord(‘b‘))#打印字符串对应的ascii码
30 print(dir(1))#打印传入对象的可调用方法
31 print(exec(‘def a():pass‘))#执行python代码
32 eval()#也是用来执行Python代码的，只能执行一些简单的代码，比如说运算,[],{}。
33 print(eval(‘[1,2,3,4]‘))
34 print(filter(lambda x:x>5,[12,3,12,2,1,2,35]))#把后面的迭代对象根据前面的方法筛选
35 print(map(lambda x:x>5,[1,2,3,4,5,6]))
36 print(max(111,12))#取最大值
37 print(min(1,34,5))#取最小值
38 print(abs(-1))#取绝对值
39 print(round(11.119,2))#取几位小数
40 print(sorted([2,31,34,6,1,23,4]))#排序 和sort()方法一样

十二，json串处理

 1 #读取json文件，把json转为字典
 2 import json
 3 #json串是一个字符串
 4 #方法一：
 5 f = open(‘product.json‘,encoding=‘utf-8‘)
 6 res=f.read()
 7 product_dic =json.loads(res)#把json串变为字典
 8 print(type(product_dic))
 9 print(json.loads(res))
10 # 方法二：
11 f = open(‘product.json‘,encoding=‘utf-8‘)
12 print(json.load(f))#传一个文件对象，他会帮你读文件，不需要我们自己再读
13 
14 
15 # 注意
16 # 使用json.loads()这个函数，是需要先读取文件，然后在转为字典
17 # json.load()这个是直接写入文件名，他自己帮我读文件然后直接转换为字典
18 
19 
20 #把字典转为json，然后写到文件里面
21 d  = {
22     ‘张三‘:{
23         ‘addr‘:‘北京‘,
24         ‘age‘:28
25     },
26     ‘李四‘:{
27         ‘addr‘:‘广州‘,
28         ‘age‘:16
29     }
30 }
31 # 方法一：
32 fw = open(‘user_info.json‘,‘w‘,encoding=‘utf-8‘)
33 dic_json = json.dumps(d,ensure_ascii=False,indent=3)#把字典转为json,字典转为字符串
34 fw.write(dic_json)
35 
36 # 方法二
37 fw = open(‘user_info.json‘,‘w‘,encoding=‘utf-8‘)
38 json.dump(d,fw,ensure_ascii=False,indent=3)#操作文件
39 
40 #这个参数代表显示中文：ensure_ascii=False
41 #代表缩进几个：indent=3)

文件json的练习

 1 import json
 2 def op_data(filename,dic=None):
 3     if dic:#写入进去文件
 4         with open(filename,‘w‘,encoding=‘utf-8‘) as fw:
 5             json.dump(dic,fw,ensure_ascii=False,indent=4)
 6     else:#读取文件
 7         with open(filename,encoding=‘utf-8‘) as fr:
 8             return json.load(fr)
 9 
10 FILE_NAME=‘user_info.json‘
11 all_users = op_data(FILE_NAME)
12 for i in range(3):
13     choice = input(‘输入：1，注册，2，删除‘)
14     if choice ==‘1‘:
15         username=input(‘username:‘)
16         pwd = input(‘pwd:‘)
17         if username not in all_users:
18             all_users[username]=pwd
19             op_data(FILE_NAME,all_users)
20     elif choice==‘2‘:
21         username = input(‘username:‘)
22         all_users.pop(username)
23         op_data(FILE_NAME, all_users)

十三。模块，模块的操作方式

 1 # 模块其实就是一个Python文件
 2 # 1.标准模块，标准包
 3 # #python自带的这些模块，直接import的模块
 4 # import string,random,datetime,os,json
 5 # 2、第三方模块，别人写好的一些模块，你要安装之后才可以用
 6 #     #1、傻瓜式的
 7 #         pip install pymysql  (主要是在cmd命令框里面输入命令进行安装)
 8 #         1、没有pip命令的怎么搞：（提示pip不是内部命令）
 9 #             1、pycharm里面点左边栏python console
10 #             2、找到python安装目录
11 #             3、然后把安装目录下的scripts目录，加入到环境变量里面即可
12 #             ps：环境变量在PATH里面加
13 #         2、Unknown or unsupported command ‘install‘ 出来这个问提怎么解决
14 #             1、打开    C:\strawberry\perl\bin\
15 #             2、把这个目录下的pip 都改成其他的名字，这个对其他的没有影响
16 #     #2、手动安装
17 #         1、whl结尾的安装包
18 #             pip install redis-2.10.6-py2.py3-none-any.whl
19 #         2、.tar.gz结尾的安装包
20 #             1、解压这个压缩包
21 #             2、进入到这个解压之后的文件夹里面
22 #             3、在命令行里面运行 python setup.py install
23 # 
24 # 3、自己写的python文件
25 
26 
27 
28 
29 #模块的使用
30 import random,string
31 print(string.printable)#代表数字+字母+特殊字母
32 print(random.randint(1,10))#随机取整数
33 print(round(random.uniform(1,99),2))#取随机小数
34 print(random.choice([1,2,3,4]))#只能随机取一个元素
35 print(random.sample(string.printable,5))#随机取多个元素，返回是list
36 #洗牌
37 pickts = [‘A‘,‘Q‘,‘J‘,‘K‘,1,2]
38 random.shuffle(pickts)#洗牌 只能传list
39 print(pickts)