python 风格的代码
- python 风格的代码
-
- 列表推导式
- 集合推导式
- 字典推导式
- 关于None
- 判空操作
- 关于API
- python内置函数的自定义
- 类方法和实例方法以及静态方法
-
列表推导式
b = [,,,,,,,]
chs = [value ** for value in b]
print(chs)
# [1,4,9,16,25,36,49,64]
chs = [value ** for value in b if value>=]
print(chs)
#[25,36,49,64]
集合推导式
a = {,,,,,,,}
chs = {value ** for value in a if value>=}
print(chs)
字典推导式
students = {
'越今朝' : ,
'越祁' : ,
'云天河' :
}
b = [key for key,value in students.items()] #eg1
print(b)
# 输出: ['越今朝','越祁','云天河']
b = {value:key for key,value in students.items()} #eg2
print(b)
# 输出: {20:'越今朝',18:'越祁',20:'云天河'}
b = (key for key,value in students.items()) #eg3
#print(b)
# 输出: <generator object <genexpr> at 0x03296270>
for x in b:
print(x)
# 输出:
# 越今朝
# 越祁
# 云天河
关于None
'''
None 空，不等同于空字符串 空的列表 0 False
'''
a = ''
b = False
c = []
print(a is None)
print(b == None)
print(c == None)
#输出 False
#None 的类型
print(type(None))
#输出 <class 'NoneType'>
判空操作
#eg1
def fun():
return None
a = fun()
if not a:
print('S')
else:
print('F')
if a is None:
print('S')
else:
print('F')
#输出 S S
#eg2
a = []
if not a:
print('S')
else:
print('F')
if a is None:
print('S')
else:
print('F')
#输出 S F 此时a为空列表而非None
#判空操作一般如下
if a :
...
if not a:
...
关于API
什么是API?
以C语言为例，我们使用fopen()函数可以打开一个文件，感觉非常简单。
文件保存在硬盘上，要经过复杂的处理才能显示，
这些细节对我们来说是透明的，由操作系统完成。
也就是说，我们调用fopen()函数来通知操作系统，让操作系统打开一个文件。
那么，我们如何告诉操作系统打开文件呢？
看似简单的操作到底层都非常复杂，打开文件首先要扫描硬盘，找到文件的位置，然后从文件中读取一部分数据，将数据放进I/O缓冲区，放进内存；这些数据都是0、1序列，还要对照ASCII表或Unicode表”翻译“成字符，再在显示器上显示出来。这个过程如果要让程序员来完成，那简直是噩梦！
怎么办呢？操作系统想了一个很好的办法，它预先把这些复杂的操作写在一个函数里面，编译成一个组件（一般是动态链接库），随操作系统一起发布，并配上说明文档，程序员只需要简单地调用这些函数就可以完成复杂的工作，让编程变得简单有趣。这些封装好的函数，就叫做API(Application Programming Interface)，即应用程序编程接口。
说得更加通俗易懂一些，别人写好的代码，或者编译好的程序，提供给你使用，就叫做API。你使用了别人代码（或者程序）中的某个函数、类、对象，就叫做使用了某个API。
python内置函数的自定义
class Complex():
def __init__(self, real=, vir=):
self.real = real
'''
若属性名称以 __ 开始
则该属性是私有的
不能通过对象在类外面直接访问
能在类中访问（通过成员函数访问）
'''
self.__vir = vir
def __str__(self):
data = str(self.real) + ' + ' + str(self.__str) + '.'
return data
# 此函数被设置为私有，不能通过实例直接调用
def __note(self):
print('实部: %.2f, 虚部: %.2f' % (self.real, self.__vir))
def __del__(self):
print('call __del__ function...')
def test(self):
self.__note()
c = Complex(, )
c1 = Complex(, )
print(c.real)
c.test()
print('-----------------------')
del c
print('------------------------')
del c1
print('-------------------------')
'''
输出:
2
实部: 2.00, 虚部: 3.14
-----------------------
call __del__ function...
------------------------
call __del__ function...
-------------------------
'''
class Stu():
'''
若属性在类中,方法外定义
则为共有的属性
可以通过类名直接访问
'''
baseId = # --> 类属性
def __init__(self, name, score=):
self.name = name # --> 实例属性
self.score = score
self.sid = Stu.baseId
Stu.baseId +=
def __str__(self):
msg = 'id: ' + str(self.sid) + ' name:' + str(self.name) \
+ 'score: ' + str(self.score)
return msg
s1 = Stu('jack', )
s2 = Stu('rose', )
print(s2.sid)
print(s1.sid)
print(s1)
print(s2)
'''
1002
1001
id: 1001 name:jackscore: 90
id: 1002 name:rosescore: 78
'''
类方法和实例方法以及静态方法
#类方法 --> 操作类属性
class Stu():
baseId = # 类属性
def __init__(self, name = "", score = ): #实例方法
self.name = name
self.score = score
self.sid = Stu.getBaseId()
Stu.setBaseId()
def __str__(self):
msg = "id:%d, name:%s, score:%.2f"%(self.sid, self.name, self.score)
return msg
@classmethod #类方法
def getBaseId(cls):
return cls.baseId
@classmethod
def setBaseId(cls, num):
cls.baseId += num # --> Stu.baseId += num
def fun(self):
print("call fun ....")
@classmethod
def gg(cls):
print("call class method gg....")
@classmethod
def test(cls):
#不能在类方法中直接操作实例属性及调用实例方法
#print(cls.name) #error
#cls.fun() #error
Stu.gg()
cls.gg() # ---> Stu.gg()
print("call test ...")
s = Stu();
s.fun()
stu = Stu("jack", )
print(stu)
stu2 = Stu("rose", )
print(stu2)
stu2.test()
静态方法
'''
一般将不操作类属性及实例属性, 但是功能又归属于
该类的函数定义为静态函数
'''
class Stu():
baseId =
@staticmethod
def fun():
# print(baseId)
print(Stu.baseId)
s = Stu()
s.fun()
![运维工具整理[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)