单行注释 #
多行注释 ''' '''
输入print
%s
字符串的占位符
%d
数字的占位符
如语句中有占位符那么所有的%
都是占位符,可以用%%
转义
n**m
n的m次幂
逻辑运算符
-
and
并且 -
or
或者 -
not
非的意思 -
运算顺序
-
and or not
同时存在 先算括号然后算not
然后算and
最后算or
-
x or y
如果x==0,那么就是y,否则就是x,记住and跟or相反,如果x==0,那么就是x,否则就是y
-
bit_length()
二进制的长度
bool()
强制转化为boolean类型
空的东西都是Flase,非空的东西都是true
切片可以对字符串进行截取
- 语法
s[起始位置:结束位置]
包左不包右 - 语法
s[其实位置:结束位置:步长]
步长是没几个取一个,就是取后一个
字符串是不可变的对象,所以任何操作对原字符串本身是不会发生改变的
字符串操作
capitalize
首字母大写
lower
全部转换成小写
upper
全部装换成大写
swapcase
大小写互相交互位置
title()
单词的首字母大写
strip
去掉空格
lstrip
去掉左边空格
rstrip
去掉右边空格
split
切割
format
指定位置的索引 {}
startswith
判断字符串是不是某某开头
endswith
判断字符串是不是某某结尾
count(a)
查找"a"出现的次数
find("aa")
查找"aa"出现的位置,如果没有返回-1
isalnum
判断是否有字母和数字组成
isalpha
判断是否由字母组成
isdigit
判断是否有数字组成
isnumeric
判断数字(中文)
len()
内置函数.直接使用.不用点操作.判断字符串的长度
for 变量 in 可迭代对象
循环遍历
元组不可变,只读 ("a",) tuple 元组中的元素之时不允许删除但是我们可以删除整个元祖
- 元祖的不可变的意思是子元素是不可变,而子元素内部的子元素是可以变,这取决于子元素是否是可变对象
range(开始,结束,步长) 数字
insert
索引添加
lst.insert(1,"刘德华")
extend
迭代添加(用新列表扩展原来的列表)
lst.extend(["马化腾","小泽"])
字典 dict
字典的key必须是可哈希的,不可变,value没有限制
不是按照我们保存的顺序保存的,无序的
增
setdefault()
如果字典中已经包含了这个key,不在继续保存- 如果key重复了,会替换原来的value
dict.update(dict2)
- 把字典参数dict2的key/value对更新到字典dict里,如果键值有重复,更新替换
删除
pop()
删除一个元素返回valuepopitem()
随机删除clear()
清空
查询
div[key]
如果key不存在就会报错- get("aa","bb") 可以通过key来获取value的值,如果key不存在,返回None,可以给出一个默认值,当key不存在的时候返回默认值
keys
返回所有的key,虽然不是列表,但是可以迭代循环
values
返回所有的value
items
拿到所有的键值对
enumerate
枚举
is
比较内存地址是否相等
小数据池:字符串 数字
字符串
- 不能有特殊字符
- s * 20还是同一个地址,s * 21以后就是两个地址
数字的范围: -5-- 256
编码
各个编码之间的二进制,是不能相互识别的,会产生乱码
文件的存储,传输,不能是unicode(只能是utf-8 utf-16 gbk )
str 在内存中是用unicode编码
bytes
类型
s=b'alex'
encode 编码,如何将str-> bytes
decode
解码
fromkeys
- dic.fromkeys(keys,value) 返回的是一个字典 ,将keys的所有元素分别打印,对应的是value
join()
把列表变成字符串
列表不能再循环的时候删除,因为索引会跟着改变
# # 冒泡排序
# # lst=[86,3,5,7,23,53,13]
# # for i in range(len(lst)): # 记录内部排序的次数
# # i=0
# # while i<len(lst)-1:
# # if lst[i]>lst[i+1]:
# # lst[i],lst[i+1]=lst[i+1],lst[i]
# # i=i+1
文件操作
r,rb
只读(字节b)
w,wb
只写
a,ab
追加
r+
读写
在r+模式下,如果读写了内容,不论读取内容多少,光标显示的是多少,在写入或者操作文件的时候都是在结尾进行的操作
read
w+
写读
a+
写读(追加写读)
seek(n)
光标移动的位置
seek(0)
开头seek(0,)
第二个参数 0:在开头,1:在当前,2:末尾
write
在没有任何操作之前进行写,在开头写,如果读取过后就在末尾写
tell()
移动到当前位置
文件修改
-
创建新文件,把修改后的内容写入新文件,删除老文件,重命名新文件
rename
改名字-
import os
flush()
刷新缓冲区
def 函数名
三元运算符
a if a>b else b
*food
可以传入任意的位置参数,动态参数必须在位置参数后面,收到的内容是元组tuple
**
来接收动态关键字参数
关键字参数必须在位置参数后面,否则参数会混乱
顺序:
位置参数>*args>默认值参数>**kwargs
globals
全局作用域
不再使用局部作用域中的内容而改成全局作用域中的变量
nonlocal
表示在局部作用中,调用父级使用空间中的变量(父级使用内部变量)
locals()
局部作用域
sum()
求和
def extendList(val,list=[]):
list.append(val)
return list
list1=extendList(10)
print("list1=%s"% list1)
# list=[10]
list2=extendList(123,[])
print("list=%s" % list2)
# list=[123]
list3=extendList("a")
print("list3=%s"% list3)
# list=[10,"a"]
key没有改变所有指向同一个对象
闭包
闭包就是内层函数,对外层函数(非全部)的变量的引用
_closure_
检测函数是否是闭包,使用函数名._closure_
返回cell就是闭包,返回None就不是闭包
__iter__()
获取迭代器__next__()
迭代对象
yield
返回结果 可以让函数分段执行
send(值)
让生成器向下执行一次,给上一个yield
传一个值(第一个和最后一个是不用传的)
列表推导式
[最终的结果(变量) for 变量 in 可迭代对象 if 筛选的条件]
lst=[ i for i in range(1,15)]
生成器表达式
g=(i for i in range(10)) print(list(g)) 不同点,一个是[] 一个是(),一个是一次性给你好内存,一个是一个一个给你 得到的值不一样,列表推导式得到的值一个生成器 生成器要值的时候才去取
字典推导式
dic={lst[i]:lst2[i] for i in range(len(lst))}
集合推导式
lst=["那化腾","马化腾","王建中","张建忠","张雪峰","张雪峰","张雪峰"] s={i for i in lst} print(s) 去重
没有元组推到式,不过可以认为是生成器表达式
字典是key:value 集合是key
内置函数
iter()
迭代
next()
输出下一个
print("aa","bb","cc")
sep:分隔符 end最后
hash算法
目的是唯一,列表是不可哈希的,元组可以
callable()
是否是可以调用的
字符串的执行
eval
执行简单的运算exec
执行字符串函数
divmod
求商和余数
round
五舍六入
pow(a,b)
a的b次幂
sum()
求和
max()
最大值
min()
最小值
reversed
倒序 list()
slice()
s=slice(1,3,1)
print(lst[s])
repr
原样输出,过滤掉转义字符\n\t\r不管百分号
ord
返回编码表中的码位
chr
已知码位计算字符
format
enumerate()
把索引和元素一起获取,索引默认从0开始
lst=["A","B","c","d"]
for index,el in enumerate(lst,100):
print(index)
print(el)
all()
全部是True返回True(可迭代对象)
any()
有一个是True则是True(可迭代对象)
lembda()
匿名函数
a=lambda x:x*x 语法:lambda 参数:返回值
__name__
查看函数名
sorted
要给一个对象接受,reverseed
参数为True False 升序降序
lst=[
{"id":1,"name":"alex","age":18},
{"id":2,"name":"taibai","age":19},
{"id":3,"name":"wusir","age":13},
{"id":4,"name":"ritian","age":11},
{"id":5,"name":"nvshen","age":12},
]
def func(dic):
return dic["age"]
l1=sorted(lst,key=func)
print(l1)
filter
第一个参数是函数,第二个参数是可迭代的对象
lst=[1,3,4,5,6,7,8]
li=filter(lambda i:i%2==1,lst)
print(list(li))
list(filter(lambda dic:dic["age"]>40,lst))
map
lst=[1,2,3,4,5,6,7]
def func(i):
return i*i
li=map(func,lst)
print(list(li))
lst1=[1,3,5,6,7,8]
lst2=[2,43,4,5,6,8]
print(list(map(lambda x,y:x+y, lst1,lst2)))
#如果传入的多个参数,后面的列表要一一对应
递归
面向对象
Person.__dict__
查询类中的所有内容(不能进行增删改操作)
函数.属性
对类中的单个的变量进行增删改查
-
类名+()产生一个实例(对象,对象空间)
-
自动执行类中的
__init__
,将对象空间传给__init__
的self 参数 -
给对象封装相应的属性
-
Person.money="货币" # 增 Person.animal="中等动物" # 改 del Person.mind #删除 print(Person.__dict__)
class Count:
count = 0
def __init__(self):
Count.count = self.count + 1
查看类被调用几次
通过类名可以更改我的类中的静态变量值
Count.count=6
Count.__dict__
但是通过对象,不能改变只能引用类中的静态变量
类的两个属性
静态属性就是直接在类中定义的变量
动态属性就是定义在类中的方法
组合(不太懂)
from math import pi
# 求圆和圆环的面积和周长
class Circle:
def __init__(self,r):
self.r=r
def aera(self):
return self.r**2*pi
def perimeter(self):
return self.r*2*pi
class Ring:
def __init__(self,r1,r2):
self.r1=Circle(r1)
self.r2=Circle(r2)
def area(self):
return self.r1.aera()-self.r2.aera()
def perimeter(self):
return self.r1.perimeter()+self.r2.perimeter()
继承
只执行父类的方法:子类中不要定义与父类同名的方法
自执行子类的方法:在子类创建这个方法
既要执行子类的方法,又要执行父类的方法:
super().__init__(name,sex,age)
继承:单继承,多继承
类:经典类,新式类
新式类:凡是继承object都是新式类
python3x
所有的类都是新式类,因为python3x中的类默认继承object
经典类:不继承object都是经典类
python2x
所有的类默认都不继承object,所有类默认都是经典类,你可以让其继承新式类
单继承:新式类,经典类的查询顺序一样
多继承:
- 新式类:遵循广度优先 类名.mro()
- 经典类:遵循深度优先
- 多继承的新式类 广度优先:一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走别一条路,如果不能,则走到终点
- 多继承的经典类:一条路走到黑
- 深度优先,广度优先:只能是继承两个类的情况
继承的优点:
- 节约代码
- 规范代码
统一化接口设计
-
# class Alipay: # def __init__(self, money): # self.money = money # # def pay(self): # print("使用京东支付了%s" % self.money) # # # class Jdpay: # def __init__(self, money): # self.money = money # # def pay(self): # print("使用京东支付了%s" % self.money) def pay(obj): obj.pay() a1 = Alipay(200) j1 = Jdpay(100) pay(a1)
抽象类接口类
from abc import ABCMEta, abstractmethod
class Payment(metaclass=ABCMEta):# 抽象类(接口类)
@abstractmethod# 强制指定一个规范,凡事继承我的类中必须有pay方法,如果,如果没有就会报错
def pay(self):
pass
封装
广义的封装: 把方法和属性都封装在一个类里,定义一个规范来描述一类事物
狭义的封装: 私有化,只有在类的内部访问
__age
对于私有静态字段来说,只能在本类中,类的外部
python处处都是多态
- 一种类型的多种形态,多个子类去继承父类,那么每一个子类都是这个父类的一种形态
property
装饰器函数,内置函数,帮助你将类中的方法伪装成属性,特性
- 调用方法的时候不需要主动加括号
- 让程序的逻辑性更合理
@方法名.setter
装饰器,修改被property装饰的属性的时候会调用被这个@方法名.deleter
装饰器,修改被property装饰的属性的时候会调用被这个装饰器装饰的方法,除了self之外还有一个参数,被修改的值
静态方法
class A:
@staticmethod
def func():
print(666)
A.func()
类方法
# class A:
# name="alex"
# count=1
# @classmethod
# def func(cls): # 此方法无需对象参与
# print(cls)
# print(cls.age)
# def func2(self):
# print(self)
# class B(A):
# age=22
# def f1(self):
# pass
# # B.func()
# b1=B()
# b1.func2()
属性:将方法伪装成一个属性,代码上没有什么提升,只是更合理
@property
@属性名.setter
@属性.deleter
类方法
@classmethod
只能有类名调用(对象调用,传给cls参数也是该对象的所属类)
使用场景
1.无序对象参与
2.对类中的静态变量进行修改
3.在父类中类方法得到子类的类空间
静态方法
@staticmethod
代码性,清晰
复用性
isinstance()
判断对象所属类型,包括继承关系
issubclass()
判断类与类之间的继承关系(前面父类,后面子类)
class A:pass
class B(A):pass
print(issubclass(B,A))# True
print(issubclass(A,B))#False
反射
反射: 用字符串数据类型的变量名来访问这个变量的值
class Student:
ROLE = 'STUDENT'
# eval 这个东西 明确的写在你的代码里
print(Student.ROLE)
# 'ROLE'
# eval()
print(getattr(Student,"ROLE"))
反射的方法:getatter
hasattr
setattr
delattr
class Student:
ROLE = 'STUDENT'
@classmethod
def check_course(cls):
print('查看课程了')
@staticmethod
def login():
print("登录")
# 反射查看属性
print(Student.ROLE)
print(getattr(Student, "ROLE"))
print(Student.__dict__)
# 反射调用方法
# getattr(Student,'check_course')() #类方法
# getattr(Student,'login')() # 静态方法
num = input(">>>")
if hasattr(Student, num):
getattr(Student, num)()
setattr(a,'name','alex_SB') 对象,属性,替换的属性
单例(指向同一块内存空间)
- 如果一个类,从头到尾只有一个实例,说明从头到尾只开辟一块属于对象的空间,那么这个类就是一个单例类
__call__
相当于对象()
Lisp语言???
a.func
就是在a对象中存储了类对象的指针(想当于记录了func
地址的变量)
抽象类和接口类
classmethod
类方法的装饰器, 内置函数
staticmethod
静态方法的装饰器 内置函数
如果一个类里面的方法,既不需要用到self中的资源,也不用cls中的资源,想当于一个普通的函数
但是你由于某种原因,还要拿这个方法放在类中,这个时候,就将这个方法变成一个静态方法
某种原因:
- 你完全想用面向对象编程,所有的函数都必须写在类中
- 某个功能确确实实施这个类的方法,但是确确实实没有用过和这个类有关系的资源
列表中不要用pop(参数)
insert()
特别消耗性能,但是可以用pop() append()
import sys
mymodule=sys.modules["__mian__"]
getattr(mymodule,"变量名")
__名字__
不是被直接调用间接调用: 内置函数/面向对象中特殊语法/python提供的语法糖
__str__
:str(obj) 要求必须实现__str__
要求这个方法的返回值必须是字符串str类型
__call__
: 对象() 用类写装饰器
__len__
: 要求obj必须实现了__len__
,要求这个方法的返回值必须是数字int类型
__new__
: 在实例化的过程中,最先执行的方法,在执行init之前,用来创造一个对象,构造方法
__init__
: 在实例化的过程中,在new执行之后,自动触发的一个初始化
__repr__
是__str__
的备胎,如果有__str__
没有的话要向上找,只要父类不是object,就执行父类的__str__
,但是如果出了object之外的父类都没有__str__
方法,就执行子类的__repr__
方法,如果子类也没有,还要向上继续找父类中的__repr__
方法,一直到找不到,再执行object类中的__str__
方法
hash
hash方法
底层数据结构基于hash值寻址的优化操作
hash是一个算法,能够把某一个要存在内存里的值通过一系列计算,保证不同值的hash结果是不一样的
对同一个值在多次执行python代码的时候hash值不一样
但是对同一个值,在同一次执行python代码的时候hash值永远不变
欢迎指正错误,相互学习,欢迎加入技术学习交流群:554587323