Python学习（包括：高阶函数，局部变量与全局变量，阶乘函数，递归，嵌套函数，文件操作，类和对象，单例模式，异常等）
#coding:utf-8
def func1(a,b):
sum=a+b
# return a,b #二元组 ()可以省略， 一元组 a =（500,）
return sum # 不写return没有返回值 ,返回多个值，需要借助集合
# print(func1(100,200))
c=300 # 全局变量
a=100
list2 =[1,2,3]
def func2():
# a=200 #局部变量 ,从新定义一个局部变量（局部变量和全局变量的名字相同）
list2.append(4) # 修改全局变量的值，根据全局变量是否是可变类型
# 任何的全局变量（不管全局变量是什么类型）在函数中都是可以改变引用 ，需要global
global a
a=200
print("函数里面的",a)
# func2()
# print(a)
# print(list2)
def func3(a,b=100): # 缺省的形参一定是在普通形参后面
return a+b
# print(func3(2,300))
def func4(a,d=666,*b,**c): # 不定长形参一定在最后面
print(b)
print(c)
# func4(1,100,300,400,i=1000,j=3000)
def test1(a,list2=[1,3]):
list2.append(a)
return list2
# print(test1(100)) # [1,3,100]
# print(test1(200,[3,4])) # [3,4,200]
# print(test1(300)) # [1,3,100,300]
# 阶乘函数 ，递归函数
def test2(n): # 递归函数本质就是一个循环，必须要有循环的边界
if n<=1:
return 1
else:
return n * test2(n-1)
# print(test2(6))
# 嵌套函数, 计算一个长度为n的斐波拉契数列 [1,1,2,3,5,8,....]
def test3(n=2):
arr=[1,1]
def get_num(i): # i 代表数列中某个数字的下标
if i<=1:
return 1
else:
return arr[i-1] + arr[i-2]
for i in range(2,n):
arr.append(get_num(i))
return arr
# print(test3(10))
# 高阶函数
def test4(n,f):
return f(n)
# print(test4(6,test2))
def test5(a,b,f):
return f(a,b)
print(test5(100,200,lambda x,y:x+y)) # lambda 形参:表达式
#coding:utf-8
# 打开一个文件获得IO流
# inp=open(r"E:\test1",'r') # r"E:\test1" 里面的r代表不去解析转义符
# out =open(r"E:\test5","w")
# out.write(inp.read())
# out.close()
# inp.close()
import os
def changeFile(file):
if os.path.isdir(file):
filelist=os.listdir(file)
for f in filelist:
changeFile(os.path.join(file,f))
else:
if file.endswith(".txt"):
index=file.rfind(".txt")
source_file_name=file[:index] # 不包含后缀的原始文件文件路径
new_file_name=source_file_name+"_backup"+".txt" # 新文件名
os.rename(file,new_file_name)
changeFile(r"E:\zhangsan")
#coding:utf-8
class Person(object):
def __init__(this,name,age): # 初始化的函数,第一个形参必须是self（代表当前对象），调用函数之前，对象已经创建
this.name=name # 成员属性(对象属性)
this.age=age
def work(self): # 任何一个成员函数，第一个形参是固定的
print("%s正在工作"%self.name)
def __new__(cls, name,age): # 创建对象的时候调用的函数，1、返回值是当前对象,2、第一个形参是固定的代表当前的类，其他形参和init一样
# java 中 class.newInstance()
return object.__new__(cls)
def __str__(self): # 相当于java中toString
return "姓名:%s,年龄:%d"%(self.name,self.age)
def __del__(self):
print("对象被垃圾回收之前调用")
# p =Person("zs",34) # None
# p.work()
# print(p)
# p2=p
# del(p)
# print("程序结束")
class A:
def test1(self):
print("A 类的test1函数")
class B:
def test1(self):
print("B 类的test1函数")
class C(B,A):
def test1(self):
print("C 类的test1函数")
# c =C()
# c.test1()
# print(C.mro())
class Animal(object):
name="小猫" # 类属性
def __init__(self,type):
self.__type=type
@classmethod
def test1(cls):
print("类方法")
@staticmethod
def test2():
print("静态函数")
def work(self): # 任何一个成员函数，第一个形参是固定的
print("%s正在工作" % self.__type)
print(Animal.name)
a =Animal("猫科")
Animal.test2()
# print(a.__type)
#coding:utf-8
class Dog(object):
__instance=None
def __new__(cls):
if cls.__instance==None:
cls.__instance=object.__new__(cls)
return cls.__instance
d1 =Dog()
d2 =Dog()
print(d1==d2)
#coding:utf-8
try:
i=1/0
print("bjsxt")
except TypeError as ex:
print(ex)
finally:
print("不管有没有异常都执行")
print("hello")