B站莫烦Python基础学习笔记

定义函数

def function(a,b): 函数名function，参数a和b
注意缩进

函数默认参数

• 一般使用情况：

def function(x,y,z):
    print(x+y+z)

function(100,200,300)			# 600

• 默认参数：

这时将x，y，z都设置默认参数：字符串1，2，3。 当然，如果不想使用默认参数，函数调用时重新赋值即可

def function(x='1',y='2',z='3'):
    print(x+y+z)

function()							#123
function('2','3','4')				#234

• 注意：
  如果未提前定义的参数在已提前定义的参数后面，则会报错：
  
  红色的定义是提前默认的参数，y是没有提前定义的参数
  所以会报错：非默认参数紧跟在默认参数之后（non-default argument follows default argument）

想要默认定义的参数都放在后面

定义全局变量

global a : 定义一个全局变量a，但是不能直接global a=111

而是要

a=None
def fun ():
    global a
    a=111
    
print('past a :',a)
fun()					#经过函数内部赋值
print('new a :',a)		

看似是在函数里面定义一个全局变量，其实是对函数里面的变量进行全局化（因为即使内部声明了a，仍需要在全局先声明）才能在外部使用。

安装外部模块

cmd中输入pip install numpy
或者
pycharm中设置->Python解释器->添加第三方库

文件的读写

使用open( )函数：具体参数意义可见： https://www.runoob.com/python/python-func-open.html

创建文件

text='this is my first file\nthis is next line'
my_file=open('my file.txt','w')     		#起名my file，仅写入
my_file.write(text)								#把上面的text写入文件
my_file.close()									#关闭文件

在我们存py文件的路径下便有了

修改（追加）文件

append_text='\nappend contain'
my_file=open('my file.txt','a')     #append追加
my_file.write(append_text)
my_file.close()

读取文件

file=open('my file.txt','r')     #read读取文件到file
content=file.read()              #对file读取，赋给content
print(content)

读取每一行存为list

file=open('my file.txt','r')     #read读取文件到file
content=file.readlines()         #用readlines()方法，把file的每一行放进列表list
print(content)

把每一行存进list

当然，既然在list里面，那我们就可以用for-in将每句话输出：

for i in content:
    print(i)

一行一行读取

使用readline（）方法，对同一个文件：第一次使用时读取第一行，第二次使用时读取第二行。
且读取的类型是str

file=open('my file.txt','r')     #read读取文件到file
content1=file.readline()         #把file的第一行，以字符串类型赋值给content1
content2=file.readline()         #把file的第二行，以字符串类型赋值给content2
print(content1)
print(content2)
print(type(content1))

class类

class Abc: 声明一个名为Abc的类(命名的首字母通常是大写)

self是指向class实例的this指针，可以用来调用类的属性或者方法。若类的内部要相互调用的话，也用self定位到class。

class Caculator:
    name='fly bird'         #Caculator类的一个属性，计算器的名称
    price=18                #计算器的价格
    def add(self,x,y):      #参数self，是指向Caculator的指针，可以调用Caculator的方法或属性
        result=x+y
        print(result)
    def minus(self,x,y):        #如果类的内部要相互调用的话，用self定位到class
        result=x-y
        print(result)
    def times(self,x,y):
        result=x*y
        print(result)
    def divide(self,x,y):
        result=x/y
        print(result)
        
cal=Caculator()         #用对象cal获得Caculator这个类
print(cal.name)
cal.add(10,11)

init功能

初始化类的属性，例如本例中Caculator固有的name和price是fly bird和18。

方法中有init()函数（这是class自带的），则可以在调用时再次赋值，改变调用时c的属性。当然，这不改变原来Caculator的属性。而且，还可以在 init( ) 中初始化函数，做到：一调用这个class就执行某个函数

init（）函数中，用参数newname，赋值给Caculator的name：self.name=newname。

class Caculator:
    name='fly bird'         #Caculator类的一个属性，计算器的名称
    price=18                #计算器的价格
    def __init__(self,newname,newprice):
        self.name=newname
        self.price=newprice
        self.add(1,2)					#也可以在init中调用函数

    def add(self,x,y):      #参数self，是指向Caculator的指针，可以调用Caculator的方法或属性
        result=x+y
        print(result)
    def minus(self,x,y):        #如果类的内部要相互调用的话，用self定位到class
        result=x-y
        print(result)

print(Caculator.name)			#fly bird
c=Caculator('fish',22)			#调用时初始化
print(c.name)					#fish
print(c.price)					#22
print(Caculator.price)			#18	，原Caculator仍是固有的

也可以用默认赋值def __init__(self,newname,newprice=29):这样每次调用的时都自动重新赋上默认值price=29。
即：C.price 为 29，Caculator.price 为 18。

import 载入模块

• 用最基本语法

import time
print(time.localtime())

• 类似宏定义简化模块名

import time as t
print(t.localtime())

• 只使用模块的少数功能（不用前缀time）

from time import time,localtime		#从time模块引入time和localtime两个功能
print(time())               #不需要写time.time
print(localtime())          #不需要写time.localtime

• 使用模块的所有功能（不用前缀time）

from time import *
print(localtime())
print(gmtime())
print(time())

自定义模块

不同的函数在不同文件中，在Python文件之间的相互调用。前提是两个文件在同一个目录下（同一个文件夹里）

被调用文件formula.py中：

def function():
    print('ss')

调用文件Python.py中：

import formula

formula.function()

也可以把自己做好的模块放在电脑中存放所有外部模块的目录下，这样就不用把被调用模块和调用模块放在一个文件夹，就可以随时调用了。

用try-except捕捉报错

使本来报错的程序不中断报错，而是用变量捕捉到，然后可以把报错输出查看。

例如：打开一个不存在的文件

file=open('asdasd','r')

会报错：

捕获报错：

try:
    file=open('asdasd','r')
except Exception as e:			#Exception类型的报错，存进e
    print(e)

捕获报错且代码编译不报错：

至于except为什么选择Exception？这只是一个类型，同样还有很多别的错误类型 。

更多参数可以看这个: https://www.runoob.com/python/python-exceptions.html

一个处理报错例子

在文件中查找名为“asdasd.txt”的文件，若没有找到则询问是否新建，若找到则在文件中添加一句话：i am coming

try:
    file=open('asdasd.txt','r+')        #只读+写入方式
except Exception as e:
    print('there is no file named asdasd')
    respone=input('do you want to creat a new file?')
    if respone=='y':
        file=open('asdasd.txt','w')
    else:
        pass
else:                                   #此else对应上面except
    file.write('i am coming')
    file.close()

若报错，则输出：there is no file named asdasd。并询问是否要新建，若输入y，则open名为asdasd的新文件。
若没有报错（找到asdasd文件），则给文件写入:i am coming，最后关上文件。

zip，lambda，map

zip 合并列表

zip英文是拉链，即把多个列表合并起来，形成元组

a=[1,2,3]
b=[2,3,4]
s=list(zip(a,b))			#如果不转换为list则只能获得object
print(s)					#[(1, 2), (2, 3), (3, 4)]

每个列表有三个元素，所以最终zip出了三个元组

若要输出：

for i,j in s:				#i和j自动获取s每个元组中的第一个，第二个值
    print(i*2,j*3)

lambda 定义简单函数

相对def一个函数，lambda定义简单函数更为方便，只需写出参数和算式即可。

def fun1(x,y):
    print(x+y)
fun1(2,3)

fun2=lambda x,y:x+y         #不用括号包住参数，直接写运算，自动return
print(fun2(2,3))

用map包装函数及参数

list(map(fun1,[1,3],[2,5])) 即包裹函数fun1且,第一个方括号内是参数x的值，第二个是y的值。最后使用list转换，使输出为列表形式

def fun1(x,y):
    print(x+y)

list(map(fun1,[1,2],[3,5]))

输出：4和7 分别是1+3 和 2+5
但是其输出机制我还没有搞清楚：不转换list时候输出为object，转换后自动print并换行输出结果

浅复制copy和深复制deepcopy

在复制出克隆体之前，若a=c，则两个变量的id相同，改变a的任意值，c的值也会变化。

浅复制

import copy库，然后用c=copy.copy(a)，将a拷贝到克隆体c上，就可以做到修改c不影响a。

import copy
a=[11,22,33]
c=a
print(id(a))				#2345350338368
print(id(c))				#2345350338368
c=copy.copy(a)
print(id(c))				#2345349923968  地址发生变化
c[1]=9999
print(a)					#[11, 22, 33]	a不变
print(c)					#[11, 9999, 33]	仅修改c中的22为9999

浅复制的缺点

b=[11,22,[33,44]]
d=copy.copy(b)              #使用浅copy
print(d)
print(id(b)==id(d))         #d和d的id不同
d[0]=0                      #修改d[0]的值
print(d)                    #[0, 22, [33, 44]]  
print(b)                    #[11, 22, [33, 44]] b不发生修改
d[2][1]=999
print(d)                    #[0, 22, [33, 999]]
print(b)                    #[0, 22, [33, 999]] b也发生了修改

浅拷贝只能做到拷贝父对象指针（指向b和d）
而子对象指针（指向b[2]列表）没有被复制，所以修改d[2][1]也会影响b内的值

深复制deepcopy

完全赋值整个对象，任何部分都不会发生使用共用内存的情况。
语句：d=copy.deepcopy(b)

简单引用

c=a就是两者共用同一存储，id相同，修改一个另一个也跟着修改。