- 字典:‘键值对’的无序可变序列,键不可重复,值可以
- 字典的创建
1.直接创建
a={‘name’:‘oydq’,‘age’:18}
2.dict创建
a=dict([(“name”,“oydq”),(“age”,18)])
3.zip创建
k=[‘name’,‘age’]
v=[‘oydq’,18]
d=dict(zip(k,v))
4.通过fromkeys创建值为空的字典
a=dict.fromkeys([‘name’,‘age’]) - 1.通过键获得值,不存在抛出异常
a[‘name’] ##‘oydq’
2.get() 方法得到,不存在返回null
a.get(‘name’)
3.列出所有的键值对
a.items()
4.列出所有的键
a.keys()
5.列出所有的值
a.values() - len()键值对的个数
- 检测一个键是否在字典中
‘name’ in a ##true
字典元素添加
a[‘address’]=‘湖南’(原来不存在)
修改
a[‘name’]=‘oydw’
新字典键值对全部添加到旧字典上,如果键有重复,直接覆盖
a={‘name’=‘xm’,‘age’=18}
b={‘name’=‘xh’,‘address’=‘江西’}
a.update(b)
a ##name=‘xh’,age=18,address=‘江西’
字典元素删除
del()删除指定键值对,clear()删除所有键值对,pop()删除指定键值对,返回对应值
del(a.[‘name’])
b=a.pop(‘age’)
b ##18
popitem()随机删除和返回键值对
序列解包,可用于列表、字典,方便多个变量赋值
x,y,z=(20,30,10)
(a,b,c)=(20,30,10)
[a,b,c]=[20,30,10]
s={‘name’=‘xm’,‘age’=18}
a,b=s
a##‘name’
b##‘age’
c,d=s.values()
c##‘xm’
d##18
e=s.items()
e##(‘name’,‘xm’)
e[0]##‘name’
e[1]##‘xm’
注意:
1.不要在遍历字典同时进行字典的修改
2.字典空间换时间
集合
无序可变,元素不能重复
集合底层是字典,集合的所有元素都是字典中的键对象,因此不能重复的且唯一
使用{}创建集合对象,并用add()方法添加元素
a={3,5,7}
a.add(9)
a ##{9,3,5,7}
用set(),将列表、元组等可迭代的对象转化成集合,如果数据存在重复数据,只保留一个
a=[3,5,7]
b=set(a)
b##{3,5,7}
remove()删除指定元素,clear()清空
a={3,5,7}
a.remove(5)
a##{3,7}
交集,并集,差集
a={3,5,7}
b={3,6,8,9,5}
a|b 或a.union(b)##并集{3,3,5,5,6,7,8,9}
a&b 或a.intersection(b)##交集{3,5}
a-b 或a.difference(b)##差集{7}
if 语句中空的列表是false
三元条件运算符
条件为真时的值 if (条件表达式)else 条件为假的值
if 条件表达式1:
语句块1
elif 条件表达式2:
语句块2
…
for x in (20,10,33)
循环代码优化
1.尽量减少循环内部不必要的计算。
2.嵌套循环中,尽量减少内部循环计算,尽可能向外提。
3.尽量使用局部变量。
zip()并行迭代
names=(‘xh’,‘xm’,‘xj’,‘xt’)
ages=(18,25,16)
jobs=(‘ls’,‘cxy’,‘gwy’)
for name,age,job in zip(names,ages,jobs):
print("{0}–{1}–{2}".format(name,age,job))
#xh–18–ls xm–25–cxy xj–16–gwy
或
for i in range(3):
print("{0}–{1}–{2}".format(names[i],ages[i],jobs[i]))
#xh–18–ls xm–25–cxy xj–16–gwy
推导式创建序列
1.列表推导式
[表达式 for item in 可迭代对象 if 条件判断]
[x for x in range(1,5)] -->[1,2,3,4]
[a2 for x in range(1,20) if x%5==0] -->[10,20,30]
a=[(m,n) for i in range(1,3) for j in range(1,3)]
#(1,1),(1,2),(2,1),(2,2)
2.字典推导式
{key:value for 表达式 in 可迭代对象}
t=“i love you,i love oydq,i love oudw”
k={x:t.count(x) for x in t}
#统计各字母出现的次数
#{‘i’: 3, ’ ': 6, ‘l’: 3, ‘o’: 6, ‘v’: 3, ‘e’: 3, ‘y’: 2, ‘u’: 2, ‘,’: 2, ‘d’: 2, ‘q’: 1, ‘w’: 1}
3.集合推导式
{表达式 for item in 可迭代对象 if 条件判断}
{x for x in range(1,5)} -->{1,2,3,4}
{a2 for x in range(1,20) if x%5==0} -->{10,20,30}
a={(m,n) for i in range(1,3) for j in range(1,3)}
4.生成器推导器(生成元组)
元组没有推导式
a=(x2 for x in range(5)) -->0,2,4,6,8
函数定义
def 函数名 ([参数列表])
‘’‘注释’’’
函数体
return 返回值
函数调用
函数名(参数);
形参无需指明数据类型
函数里用’’‘注释’’’
函数参数不以值传递!
传递可变对象(字典、列表、集合、自定义对象)的引用:在函数体中不创建新的对象拷贝,直接可以修改所传递的对象。
传递不可变对象(元组、字符串、int、float、布尔值)的引用:由于不可对象不可修改,系统会创建一个新对象。
浅拷贝copy()、深拷贝deepcopy() import copy
可变参数:
参数 将多个参数收集到一个“元组”里
**参数 将多个参数收集到一个“字典”里
lambda 表达式
lambda 参数 : 表达式 -->生成匿名函数
g=[lambda a:a2,lambda b:b-1]#定义lambda表达式
g[0](6),g[1](5)#调用lambda表达式
eval()函数
将字符串str当成有效的表达式来求值并返回计算结果
eval(print(“abc”)) #abc
nonlocal 用来声明外层局部变量
global 用来声明全局变量
LEGB规则
查找名称顺序,函数或类的方法内部->嵌套函数->模块中的全局变量->Python为自己保留的特殊名称
类的定义
class 类名(首字母大写):类体
构造函数_init_()
def init (self,参数列表):函数体#实例方法self参数必须位于第一个参数,类似于this的作用
实例化
a=类名(参数列表)
a.实例属性=值
a.实例方法
类方法定义
@classmethod
def 类方法名(cls,参数列表):#类方法cls参数必须位于第一个参数,类似于this的作用
函数体
类名.类方法名
静态方法定义
@staticmethod
def 静态方法名(参数列表):
函数体
静态方法不可访问实例属性与方法
与普通函数没啥区别,只不过需要类调用
类名.静态方法名
def del(self)析构函数,自动垃圾回收
call_方法和可调用对象
方法没有重载
Python的动态性
class Person:
def work(self):
print(“努力上班”)
def play_game(s):
print("{0}在玩游戏".format(s))
Person.play=play_game
p=Person()
p.work()
p.play()#Person.play§
实例化属性加__属性名设置私有属性(两条下划线)
类的外部不可直接访问,但可以用_类名__属性名间接访问
实例化私有方法 def a(): (两条下划线)
类的外部不可直接访问,但可以用_类名__方法名()间接访问
类属性,类方法私有同实例属性和实例方法形式
@property 装饰器
get(),set()方法访问私有属性
继承
class 父类:pass
class 子类(父类):pass
def init (self,参数列表):函数体
父类.init (self,参数列表)#调父类构造器
方法重写
子类重写父类方法,覆盖父类方法
支持多重继承,尽量避免使用,
class 父类1:pass
class 父类2:pass
class 子类(父类1,父类2):pass
mro()方法解析顺序
super()获取父类的定义
class A:
def ttt(self):
print(“A”,self)
class B(A):
def ttt(self):
super().ttt()
print(“B”,self)
B().ttt()
‘’‘A <main.B object at 0x031EB3A0>
B <main.B object at 0x031EB3A0>’’’
多态
class 父类:pass
class 子类1(父类):pass
class 子类2(父类):pass
class 子类3(父类):pass
特殊方法
重写特殊方法可以实现运算符的重载
打印的特殊方法__repr、str
加号的特殊方法__add_
class JIA:
def add(self,a,b):
self.sum=a+b2
特殊属性