Python学习（基础知识2）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、python文件基本操作

1.单个文件的读写

在python中，对文件的操作分为两种，一种是系统级操作，作用于文件本身，包括对文件的删除和权限修改；另一种是应用级操作，作用于文件的内容，包括文件的写入和读取。
文件的应用级操作分为三步：
1.打开文件，使用open()函数，返回一个文件对象；
语法格式：
file=open（filename[,mode=‘r/w’[,buffering=-1[,encoding=None]]]）

f=open("hello.txt",encoding="utf-8",mode="w+",buffering=-1)

2.对文件进行读或写的操作：读取文件用read(),readline(),readlines()函数；写入文件内容用write（）函数；
注意：read()和readlines()函数返回的内容相同，但是格式不同，read()返回的为字符串，readlines()返回的为列表。
语法格式：
file.read() 或者file.read([size])

print(f.read())

处理大文件读取的思路：
利用f.read([size])，防止文件内容过大，内存溢出。
这里用到了with（） as ，这个函数可以自动地分配并释放资源，不用在手动调用close()函数。

with open("demo.txt",mode='rb') as f:
    while True:
        block=f.read(1024)
        if not block:
            break

write(stirng)函数可以实现内容复制，用法如下：

f=open("hello.txt",mode="w+")
f.write("hello world\n")
f.write("2021\n")
f.close()

writelines()的用法：

f1=open('demo.txt')
lines=f1.readlines();
f=open("hello.txt",mode="w+")
f.write("hello world\n")
f.write("2021\n")
f.writelines(lines)
f.close()
f1.close()

tell()和seek()的用法：
tell()函数用于判断文件指针当前的位置，seek()函数用于将文件指针移动到文件指定的位置。

f1=open('demo.txt')
print(f1.read(5))
print(f1.tell())

seek(offset,whence=0)

offset：开始的偏移量，也就是代表需要移动偏移的字节数

whence：给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

3.关闭文件，当完成第2步后，需要关闭文件，用close（）函数。

2.多个文件的读写

通过fileinput(）模块的input()函数实现同时打开多个文件，并逐个读取文件的内容。比如文件内容的操作，可以实现先对内容进行备份，再执行对内容的操作。
语法格式如下：
fileinput.input(（files=“filename1, filename2, …”, inplace=False, backup=’’, bufsize=0, mode=‘r’, openhook=None）)
◆files：多个文件的路径列表；
◆inplace：用于指定是否将标准输出的结果写回到文件，此参数默认值为False；
◆backup：用于指定备份文件的扩展名；
◆bufsize：指定缓冲区的大小，默认为0；
◆mode：打开文件的格式，默认为r（只读格式）；◆openhook：控制文件的打开方式，例如编码格式等。

for line in fileinput.input(files=('hello.txt','demo.txt'),backup='.bak',inplace=True):
    print(line.replace('good','GOOD'))
fileinput.close()

3.文件特定行的读写

用linecache()模块实现对文章内容特定行内容的读取。

print(linecache.getline('hello.txt',5))

二、Python常见的异常类型

常见的异常类型分为两种：语法错误和运行错误

1.语法错误

代码如下（示例）：

print nihao



 File "C:/Users/86186/PycharmProjects/test1/test/myfirst.py", line 217
    print nihao
          ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(nihao)?

2.运行错误

代码如下（示例）：

a=1/0

Traceback (most recent call last):
  File "C:/Users/86186/PycharmProjects/test1/test/myfirst.py", line 217, in <module>
    a=10/0
ZeroDivisionError: division by zero

运行错误产生的情况成为异常。python中 用try…except…进行异常捕获处理。

try:
   a=10/0
except:
    print("分母不可以为零，请修正")

try:
    f=open('de.txt','r')
    f.write("20210111")
except IOError:
    print("the file is not exits")
else:
    print("duxie chenggong")
    f.close()

还可以用finally来进行资源回收。

     try:
   f=open('de.txt','r')
   f.write("20210111")
except IOError:
   print("the file is not exits")
else:
   print("duxie chenggong")
   f.close()
finally:
   print("over")

三、python中函数的编程

函数是封装好可以重复使用的代码，使程序更加模块化。当调用函数时，只需要调用函数名即可。

1.函数的定义和调用

定义方法：def 函数名（形参）：代码块

def loadInt(a):
    print(a)

调用方法：函数名（实参）

b=10
loadInt(b)

2.函数的参数传递

参数分为两种类型：
可变参数：类似指针传递，如列表和字典。如fun(a),是将a真正地传过去，修改后fun外部的a也会受影响。

def changeList(mylist):
    mylist.append([1,2,3,4])
    print('函数内部的值:',mylist)

newlist=[5,6,7,8]
changeList(newlist)
print('函数外面的值：',newlist)



函数内部的值: [5, 6, 7, 8, [1, 2, 3, 4]]
函数外面的值： [5, 6, 7, 8, [1, 2, 3, 4]]

不可变参数：类似值传递。整数，字符串，元组。如fun(a)，传递的是a的值，不影响a本身。

def loadInt(a):
    a=10
    print('函数内部的值为：',a)

b=2
loadInt(b)
print('函数外部的值为：',b)






函数内部的值为： 10
函数外部的值为： 2

调用函数时常用的参数类型如下：
1.位置参数
函数调用时，实参默认按位置参数进行传递，并且和形参个数一致。

def fun_a(a,b,c):
    print('a={0}，b={1},c={2}'.format(a,b,c))
    
fun_a(19,20,30)


a=19，b=20,c=30

2.默认参数
注意：默认参数放在最后的位置。

def fun_a(a,b,c=10):
    print('a={0}，b={1},c={2}'.format(a,b,c))
    
fun_a(19,20)


a=19，b=20,c=10

3.命名参数
给参数命名，这时候可以交换参数的位置

def fun_a(a,b,c):
    print('a={0}，b={1},c={2}'.format(a,b,c))
    
fun_a(a=19,c=10,b=20)


a=19，b=20,c=10

4.可变参数
定义参数的时候，不确定参数的个数。

def fun_a(a,*b):
    print('a={0}，b={1}'.format(a,b))
    
fun_a(19，20，10)


a=19，b=(20, 30)

关键字定长参数
用**x来做为形参定义参数

def fun_a(a,**b):
    print('a={0}，b={1}'.format(a,b))
    
fun_a(19，age=20,name="zhangsan")


a=19，b={'age': 20, 'name': 'zhangsan'}

注意：*x和**x的区别：
*x代表的为元组，**x代表的为字典

3.函数的返回值

用def定义函数，用return来返回函数的返回值，返回值可以为任意类型。
语法：return【返回值】
返回值也可以为none。

def sum(a,b):
    c=a+b
    return c
m=sum(2,3)
print(m)

5

return可以在函数中出现多次，但是，只要有一个执行，就会退出函数。

def ispositivenum(a):
    if a>0:
        return True
    else:
        return False
        
print(ispositivenum(5))


True

4.函数的变量的作用域

变量分为局部变量和全局变量
局部变量只在定义的函数里有效。

def sum():
    c=20
    return c

sum()
print(c)

T    print(c)
NameError: name 'c' is not defined

全局变量指变量在整个作用域有效。定义全局变量的方法有两种，一种是在函数体外部定义。

c=30
def sum():
    print(c)
    return c

sum()
print(c)



30
30

在函数体内部定义，用关键字global修饰。

def sum():
    global c
    c=20
    return c

sum()
print(c)

5.获取特定作用域的变量

有时我们需要获取特定作用域中所有的变量。这里介绍3种。
1.globals（）用于获取全局变量。

test_name='hello world,2021'
def test():
    name='你好，2021'
    print(locals())

test()

for key,value in dict(globals()).items():
    print(key,value)

注意如果此时globals()换为locals()，效果一样。可见locals()要用在定义的函数内部。
2.locals()用于获取局部变量。

test_name='hello world,2021'
def test():
    name='你好，2021'
    print(locals())

test()

3.vars()其功能是返回一个指定object 对象范围内所有变量组成的字典。如果不传入object参数，vars() 和locals() 的作用完全相同。

test='hello'
class test1:
    name='zhangsan'
print(vars(test1))


{'__module__': '__main__', 'name': 'zhangsan', '__dict__': <attribute '__dict__' of 'test1' objects>, '__weakref__': <attribute '__weakref__' of 'test1' objects>, '__doc__': None}

6.Python局部函数及其用法

在函数体内部定义函数，被称为局部函数。
调用局部函数的方法：
1.在函数内部调用局部函数，调用外部调用函数。

def outdef():
    def indef():
        print("www.hao123.com")
    indef()

outdef()

2.将局部函数作为外部函数的返回值

def outdef():
    def indef():
        print("www.hao123.com")
    return indef()

outdef()

当局部函数的变量名和外部函数的变量名相同的时候，用nonlocal关键字修饰。

    def indef():
        nonlocal name
        name='lisi'
        print(name)
    indef()

outdef()

7.Python lambda表达式（匿名函数）及用法

lambda用来表示匿名函数，函数不再需要用def进行定义。
对于简单的函数。省去了定义函数的繁琐步骤，常用于：所用函数只用一次，并且逻辑简单。又被称为单行函数。
语法：变量名= lambda参数:表达式
◆参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数
◆表达式：不能包含循环、return，可以包含if…else…
下面的函数。

def fun():
    return 1==2
print(fun())

用lambda表示为：

a=lambda:1==2
print(a())

当有参数时：

a=lambda x,y,z:x+y+z
print(a(1,2,3))

8.Python种的递归（德罗斯特效应）

在Python中，一个函数可以调用其他函数。函数甚至也可以调用自身，这类函数称为递归函数（RecursiveFunction）。
如果一个函数直接或者间接地调用函数本身，那么就是递归函数。这意味着，函数将不断的调用本身并重复函数的内容，直到达到某个条件才返回一个结果。
所有的递归函数都有着同样的结构，这个结构由两部分组成：基础部分，递归部分。

def fun_a(n):
    if n==1:
        return n
    n=n*fun_a(n-1)
    return n
print(fun_a(10))

9.Python 函数式编程介绍

函数式编程的特点是：允许函数本身作为一个参数传入另外一个函数，还允许返回另外一个函数。
常用的如下：
map()函数
语法格式：map(function, iterable)
其中，function参数表示要传入一个函数，可以是内置函数、自定义函数或者lambda 匿名函数；
iterable表示一个或多个可迭代对象，可以是列表、字符串等。map() 函数的功能是对可迭代对象中的每个元素，都调用指定的函数，并返回一个map 对象，不是list。

def fun_a(x):
    return x**3
lsit1=range(1,10)
newlist=map(fun_a,lsit1)
print(list(newlist))

list1=['hello','world']
newlis=map(lambda x: x.upper(),list1)
print(list(newlis))

filter（）函数
语法格式：filter(function, iterable)
funcition参数表示要传入一个函数，iterable表示一个可迭代对象。
filter() 函数的功能是对iterable中的每个元素，都使用function 函数判断，并返回True 或者False，最后将返回True 的元素组成一个新的可遍历的集合。

def fun_a(n):
    return n%2==1
list1=[1,2,3,4,5,6,7,8,9]
newlist=filter(fun_a,list1)
print(list(newlist))

[1,3,5,7,9]

reduce() 函数
通常用来对一个集合做一些累积操作.
语法格式为：reduce(function, iterable)
其中，function规定必须是一个包含2 个参数的函数；
iterable表示可迭代对象。
注意：由于reduce() 函数在Python 3.x 中已经被移除，放入了functools模块，因此在使用该函数之前，需先导入functools模块，需要引用：fromfunctoolsimport reduce

from functools import reduce

lista=[1,2,3,4,5]
m=reduce(lambda x,y:x*y, lista)
print(m)


120

总结

Python基础知识差不多整理完成，后面将整理学习，Python的进阶知识。