定义函数
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相同,修改一个另一个也跟着修改。