- 字典排序
dict = {'a':1,'c':3,'b':2}
字典没有sort方法,可使用sorted排序,默认通过key排序
dict = sorted(dict),print(dict)key的排序
dict = sorted(dict,reverse = True),print(dict)逆序key
dict = sorted(dict.items),print(dict)key-value作为元组的排序列表
dict = sorted(dict.items),print({k:v for k,v in dict})实现字典的排序
使用lambda排序:
dict = sorted(dict.items(),key = lambda x:x[1],reverse = True)
#x[1]表示按照value排序,因为ict.items()是元组的列表,x[1]是元组的第二项即value,赋给要排序的关键字key
print({k:v for k,v in dict})
#用字典推导式将得到的元组列表转换成字典输出
- 字典列表排序
list = [{name':b,'age':17},{name':a,'age':15},{'name':c,'age':16}]
dict = sorted(list,key= lambda x:x['age'],reverse = True)
#按age排序,倒序,不给key的话默认用第一个属性排
print(dict)
#输出的还是字典列表
- 常用内置函数
abs(num) sorted(list) sum(list) round(a,b)小数点后取b位 eval()执行一个表达式,或字符串作为运算 exec()输出python语句 - 常用高阶函数
map(func,seq[,seq...])映射
list = [1,2,3,4,5]
newlist = map(lambda x : x*2,list) #还不如newlist = [x*2 forx in list]方便!
print(newlist)
print(list(newlist)) #将map对象转换为list打印
list2 = [3,4,5,6,7]
newlist2 = map(lambda x,y : x*y,list,list2) #map后多个对象的例子
filter(func,seq)过滤
list = [1,2,3,4,5]
newlist = filter(lambda x:x>2,list)
print(list(newlist)) #输出:[3,4,5]
#用map试试
newlist = map(lambda x:x>2,list)
print(list(newlist)) 输出:[false,false,true,true,true]
reduce(func,seq[,初始值])
from functools import reduce
list = [1,2,3,4,5]
list2 = [3,4,5,6,7]
newlist = reduce(lambda x,y : x+y,list,10)
#10是初始值,默认为0,第一步就是x=10
print(newlist) #输出:25
- 类定义
class 类名():
#类文档说明
属性
方法
例子:
#创建person类
class person():
'''
这是一个人类
'''
country = 'china' #声明类属性,并赋值
#实例属性通过构造方法来声明
#self不是关键字,代表的是当前对象
def __init__(self,name,age,sex): #构造方法
#构造方法不需要调用,在实例化时自动调用
print('我是构造方法,在实例化时调用')
self.name = name #通过self,创建实例属性,并赋值
self.age = age
self.sex = sex
#创建普通方法
def getName(self):
#在方法里面使用实例属性
print('我叫%s,来自%s'%(self.name,person.country))
#实例化对象
people01 = person('joe',18,'男') #在实例化时传递参数
#这个people01有3个属性和1个方法
#访问属性
#通过 对象名.属性名 访问实例属性
print(people01.name)
print(people01.age)
print(people01.sex)
print(getattr(people01,'name')) #通过内置方法访问属性
print(hasattr(people01,'name')) #是否有该属性,返回bool
print(setattr(people01,'name','susan')) #修改属性
delattr(people01,'name')) #删除属性
#通过对象调用实例方法
people01.getName()
#内置类属性
print(people01.__dict__) #将对象的属性通过字典形式返回
print(people01.__doc__) #查看文档说明(输出:这是一个人类)
print(person.__name__) #返回类名,不知道有啥用
print(people01.__bases__) #返回基类,也不知道有啥用
__name__
package name
def a():
print('我是a方法')
if __name__ == '__main__': #判断是否在当前脚本运行
a()
print(__name__) #在当前脚本运行,输出:__main__
在另一个文件引用:
package name2
import name #没有输出
- 继承
class Animal():
def __init__(self,name,food):
self.name = name
self.food = food
def eat(self):
print('%s eat %s'%(self.name,self.food))
class Dog(Animal):
def __init__(self,name,food,drink):
#加载父类构造方法
super().__init__(name,food)
#或者Animal.__init__(self,name,food)也行
self.drink = drink #子类自己的属性
def drinks(self): #子类自己的方法
print('%s drink %s`%(self.name,self.drink))
if __name__ = '__main__':
dog1 = Dog('金毛','骨头','可乐')
dog1.eat()
dog1.drinks()
- 多继承:若父类有相同的属性或方法,从左往右找
class A():
def a(self):
print('Aa')
class B():
def b(self)):
print('Bb')
def a(self)):
print('Ba')
class C():
def c(self)):
print('Cc')
class D(A,B,C):
def d(self)):
print('Dd')
dd = D()
dd.d() #调用自己的方法
dd.a() #输出:Aa
- 多态:重写
class A():
def a(self):
print('Aa')
class B(A)
class D(A):
def a(self)):
print('Da')
bb = B()
bb.a() #输出:Aa
dd = D()
dd.a() #输出Da
- 私有属性(相当于private)
双下划线开头的属性,不能通过 对象名.属性名 访问和修改!
外部修改私有属性,预留一个接口修改或访问,如
def getAddre(self,pwd):
if pwd == '123':
return self.__address
else:
return '权限不够'
#强制访问,尽量不这样做
print(people01._person__address)
- 静态方法和类方法
@staticmethod #静态方法:不能访问实例属性,只能访问类属性
def aa(): #不需要传递实例,没有self
print(person.country)
people01.aa()
person.aa() #推荐使用通过类名来调用静态方法
@classmethod #类方法:不能访问实例属性,
def bb(cls):
print(cls.country)
people01.bb()
person.bb() #推荐使用通过类名来调用类方法
- 模块:官方,第三方,每一个脚本都是一个模块
同一目录直接引用,不同目录从两个文件的最高相同目录开始from
创建一个包一定要创建一个init.py文件,里面有__all__ = ['moduel1','moduel2',...]表示运行被允许导入的模块 - 重新加载:模块被导入一次后,其他的导入不再有效
import test
import imp
imp.reload(test)
