主要有整型、字符串类型、布尔型
1.1字符串字符串不支持修改，若对其进行修改，会生成新的值，对原本的值不会做出修改
#例如 n1='beijing' n2=n1 n2='shanghai' print(n1) #beijing print(n2) #shanghai n3='nanjing' n4=n3 n3='guangzhou' print(n3) #guangzhou print(n4) #nanjing
字符串存在一些独有功能：
1. n2=n1.rstrip() / lstrip() 去除字符串右/左边空格
2. n2=n1.strip() 去除字符串两边的空格
3. n2=n1.startwith() /endwith 开头/结尾是否为… #True / False
4. n2=n1.upper() / lower() 将字符串变成大写/小写
5. n2=n1.isdecimal() 是否为数字 #True / False
6. n2=n1.replace(“history”,“now”) 替换
7. n2=n1.split(“,”) 切割 如按"," 切割
字符串的格式化：
n2=“姓名{}”.format(name) #拼接字符串
另外还存在一种拼接:
n2=“,”.join(name) #将name中的字符串以","的形式拼接在一起
存在几种操作
1. n1.append() 添加在最后
2. n1.insert(位置，“内容”) 插入
3. n1.remove() 删除
4. n1.choice() 随机抽取
5. n1.clear() 清空列表
6. n1.sort() 排序，没有返回值，即对n1本身操作，n1会改变，一般用于列表
n1=[12,3,5,1] n1.sort(reverse=False) # n1 =[1,3,5,12] False从小到大 True从大到小 n2=['沈阳','建筑','大学'] n2.sort(reverse=False) # n2=['大学', '建筑', '沈阳'] False 从小到大，True从大到小 按abc顺序排
7.sorted(n1) 排序，存在返回值，不会改变n1的值，一般用于任意可迭代对象
8.n1.reverse() 倒叙
元组不可修改
1.4 字典 { }{“key”: value}
key:必须为可哈希的值,（哈希值在内存中存放根据哈希值放在规定的位置，%位置看余数）
目前可哈希的：int、boot、str、tuple元组，只有这些可以做Key
value:可以为任意类型
v1=v2.get(“key”) 获取键key对应的值
v1=v2.keys() 获取键
v1=v2.values() 获取值
v1=v2.items() 获取键值对 # [[“age”,123], [“status”,True]]
索引：读取值
v1=v2[“age”]
v1=v2.get[“age”] 推荐这种方式，如果找不到对应的值会返回None，上面方法可能会报错
其他类型转换成bool时，只有0、空字符串、空列表、空元组、空字典、None 为False，其他均为True
1.6类型分类可哈希：int、bool、touple、str
不可哈希：list、dict
不可变：int、bool、touple、str
可变：list、dict
1.若有默认参数，要放在最后，不可放在前面，python不支持
2.动态参数
* 会统一将用户传入的参数变成元组，如：args=(1,) args=(1,11) args=(9,11,123123) 可以传很多个
** 也可以穿多个，但必须有格式，将参数变成字典 如：kwargs={“k”:1} kwargs={“v1”:1,“x”:11}
* 或** 结合，可以支持传任意个，如 do_something(11,22,k9=999) 11,22 打包给*，k9=999打包给**
3.返回值
返回值可以是任意类型，若没有则返回None，返回时，可以逗号分开多个值，会把它打包成一个元组
python中是以函数作为作用域，若没有函数，参数认定为全局参数
在函数中将全局变量进行引用操作，在参数前面加global
yield ：若在函数中如写：yield 1 则函数不执行，若有 next(f())才能运行该函数
可以减少内存消耗
# 生成 1000w个连续的数字
num_list = []
for item in range(10000000):
num_list.append(item)
#加入生成器的
def create_big_num(max_num):
num = 0
while True:
yield num
if num == max_num:
return
num = num + 1
obj = create_big_num(100000)
for item in obj:
print(item)
2.4装饰器
定义装饰器
def outer(func):
def inner():
print("before")
res = func() # 被装饰器的原函数
print("after")
return res
return inne
应用装饰器,会先输出 before 在函数运行输出完后，会输出after
@outer
def info3():
print("原来的info函数")
info3()
2.5 匿名函数
lambda 一行代码实现功能、适用于简单功能的函数，若复杂的不可
例：func = lambda a1,a2 : a1 + a2
内置模块
3.1 hashlib对数据进行md5加密
import hashlib
hashlilb.md5()
json模块，是所有语言通用的
就是把别人的json模式，转变成自己的python程序，字符串的转化
import json
1.反序列化
data1=json.load(data2) 将json格式变成python字符串格式
如通过爬虫将数据爬取下来后转化成Python格式 requests.get()获取
2.序列化
data1=json.dump(data2) 将python格式转成json格式
(json相当于一个格式，所有语言都可以识别，是以字符串的形式存在的)
tips：
1.json格式里面的引号都要用双引号，若在里面出现单引号，json.load会识别不出来
2.json中true、false都是小写
3.里面不能存在元组，应该是列表格式
json中并不是可以序列化所有数据类型：
字典、列表、元组、str、int、float、True、False、None这些类型可以
如果没有，可以转成字符串
v1 = os.path.abspath(“db.txt”) 绝对路径
file_path = os.path.join(“files”, “xx”, “fff”, “account.txt”) 路径拼接
v1 = os.path.exists(file_path_1) 是否存在路径 True/False
v1=os.makedirs() 创建文件夹
v1 = os.listdir(“/Users/”) 查看路径下有哪些文件，只查找当前级别，若有文件嵌套，查找不到
v1=os.walk(“/Users/”) 查看路径下有哪些文件，不仅限1级中，所有都能找到
v1=andom.randint(100,999) 随机数，范围100-999
v1=random.choice(v2) 随机选取一个元素 （用的多） √
v1=random.shuffle(v2) 随机打乱顺序
import time
v1=time.time() 时间戳
v1=time.sleep(5) 时间停顿5s
import datetime
datetime是对象形式，不是字符串，方便时间的加减
v1=datetime.datetime.now() 获取当前时间
v1 = “2022-04-14 19:18:17” 这种是字符串的格式
格式转换：
1.datetime 对象–> 字符串 v2 = v1.strftime(“%Y-%m-%d %H:%M.%S”)
2.字符串–>datetime 对象
from datetime import datetime, v1 = "2022-04-14" v2 = datetime.strptime(v1, "%Y-%m-%d")3.6 ini文件
读取ini文件，python自带的功能，且可以解析
import configparser
v1= configparser.ConfigParser()
v1.read("my.ini", encoding='utf-8')
3.7 正则表达式
正则的表达
1.字符表示（只能代表一位）
固定，例如：a、b、c
范围，例如：[a-z] [0-9] [A-Z]
数字，例如：d
字母或数字或下划线（汉字），例如：w
所有（能代表任何除了n），例如：.
2.多位表示
10个数字 d{10}
1个或n个数字 d+
0个1个数字 d?
任意个数字 d*
重复n次或重复更多次（至少一次） d{n,} 有逗号
重复n到m次 d{n,m}
tips：默认匹配是贪婪匹配，若想非贪婪匹配则要加个？，
3.分组
1）分组：加括号，提取括号内匹配的值
import re
text = "在线想要手机号15131255789。"
data_list = re.findall("15131(2d{5})", text)
print(data_list) # ['255789']
2） | “或” 可以匹配|前面的，也可以匹配|后面的
import re
text = "dsf130429191912015219k13042919591219521Xkk"
data_list = re.findall("d{17}(d|X)", text)
print(data_list) # ['9', 'X']
re模块
- findall 直接匹配所有内容，得到的是列表的形式
- match 从文本开头进行匹配，开头是的话成功，否则得到None
如果匹配成功得到值，data得到的是对象，不是匹配得到的相应内容值
应该data.group() 得到匹配成功的值
import re
text = "辽宁省沈阳市浑南区辽东地区"
data = re.match("辽d省", text)
print(data) # 对象
v1 = data.group()
print(v1)
- search 只取成功的第一个值，得到的也是对象，也需要group()
- 起始符 ^ 终止符 $ 与re.match相结合
可以用于校验，保证起始和终止都一致才能成功
import re
text = input("请输入手机号：")
mtc = re.match("^1[3-9]d{9}$", text)
if mtc:
print("格式正确", text)
else:
print("格式错误")
4.面向对象
1.面向过程编程：功能从上到下划分
2.函数式编程：功能拆分 名字–> 看各部分功能可只看部分代码 推荐√
3.面向对象编程：
定义类、定义方法、根据类创建对象以及运用self
存在三大特征：
封装、继承、多态
1) 封装：将数据封装到一个对象中，后期再去对象中获取已封装的数据。
2) 继承：
注意事项：
1…self到底是谁？谁执行的方法，self就是谁，在初始化类之后
class Base:
def f1(self):
print("Base.f1")
class Foo(Base):
def f2(self):
print("Foo.f2")
class Bar(Foo):
def f3(self):
print("Bar.f3")
obj = Bar()
obj.f3()
obj.f2()
obj.f1()
obj3 = Foo()
obj3.f2()
obj3.f1()
obj3.f3() # 报错
obj4 = Base()
obj4.f1()
2…执行类中的方法时,优先去哪里找？一定要先看对象方法,看对象是谁？
对象是由那个类创建出来的，优先就去这个类中找
注意：self是哪个类的对象；对象.方法 => 对象传递给self
class Base:
def f1(self):
print("base.f1")
def f2(self): # obj son类的对象
print("base.f2")
self.f1() # obj son类的对象
class Son(Base):
def f1(self):
print("son.f1")
obj = Son()
obj.f2()
# 输出
base.f2
son.f1
3…多继承（python独有） 在括号里按从左向右的顺序找，左边没有则找右面
3) 多态 python原生支持多态，其他语言可能要写一些代码做支撑才可以
多态就是支持各种形态，参数可以为任意类型如int、str、list等
1.反射 两个内置函数
data = getattr(对象,"成员名称") # 对象.成员名称 print(data) setattr(对象,"成员名称",值) # 对象.成员名称 = 值 # 好处：直接以字符串的形式操控。
2.如何获取对象中已封装的所有值
class Foo:
def __init__(self):
self.x1 = "北京"
self.x2 = "上海"
obj = Foo()
obj.x3 = 666
# {'x1': '北京', 'x2': '上海', 'x3': 666}
print(obj.__dict__)
4.1变量
1.实例变量：属于对象，python中比较灵活
2.类变量：属于类
（每个对象中都有同样的值，为了避免内存的开销，使用类变量只保存一份即可）
类变量中：类M1() ，可以M1.mess或者 对象obj.mess 来访问
4.2方法1.绑定方法：至少有一个self参数，那个对象调用此方法时，self就是就谁
调用时： 对象.方法名称()
2.静态方法：当方法中不会用到任何 对象中封装的值时，可以使用静态方法。
定义时：可有有任意个参数，Python内部不会帮他去传递任何参数。
@staticmethod
调用时：类名.方法名称(…)
对象.方法名称(…) – python可以
3.类方法，在方法中不需要用对象，而是需要用当前类，就需要用cls
定义时：至少有一个cls参数，cls是python内部自动传递的，cls的值等于当前类名。
@classmethod
调用时：类名.方法名称(…) cls=当前类
对象.方法名称(…) cls=当前类
class Message:
def __init__(self, n, m):
self.x1 = n
self.x2 = m
def send(self, to, content):
print(self.x1, self.x2, to, content)
@staticmethod
def show():
pass
@classmethod
def get_info(cls):
pass
obj = Message("北京", "上海")
obj.send("房山", "普通")
Message.show()
obj.show()
4.3属性
@property 把方法变成属性，不支持传参数，读取方便
class Message:
def __init__(self, n, m):
self.x1 = n
self.x2 = m
@property
def send(self):
return "123"
obj = Message("x", "o")
data = obj.send
print(data)
属性的扩展：
class Message:
def __init__(self, n, m):
self.x1 = n
self.x2 = m
@property
def x(self):
return "123"
@x.setter
def x(self, value):
pass
@x.deleter
def x(self):
pass
obj = Message(11, 22)
print(obj.x)
obj.x = 999
del obj.x
class Message:
def __init__(self, n, m):
self.x1 = n
self.x2 = m
def getx(self):
pass
def setx(self, value):
pass
def delx(self):
pass
x = property(getx, setx, delx)
obj = Message(11,22)
obj.x # 调用 getx方法并获取返回值
obj.x = 123 # 调用 setx方法
del obj.x # 调用 delx
4.4特殊成员
1.__init__, 类() -> 初始化方法
2.__new__，构造方法，创建空对象
一般在初始化方法之前运行，一般不写，系统会内部自动生成
3.__call__ 类名() 对象()
对象() 会调用到call方法，底层源码会存在
类() ->初始化方法
class Foo(object):
def __init__(self, name):
self.name = name
def __call__(self, *args, **kwargs):
print("call")
return 666
# 类() -> init
obj = Foo("小明")
# 对象() --> call
v1 = obj()
print(v1)
4.__str__ 可以直接输出print(obj)对象，即调用__str__方法
还可以将对象转换成str
5.__dict__ obj.__dict__ 获取所有成员以字典的形式输出
6.__getitem__ (self,item)
obj[‘XXX’] 调用getitem
7.__setitem__ (self,key,value)
obj[‘XXX’]=123 调用setitem
8.__delitem__ (self,item)
del obj[‘XXX’] 调用delitem
class Foo(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __getitem__(self, item):
return 999
def __setitem__(self, key, value):
pass
def __delitem__(self, item):
pass
obj = Foo("小明", 22)
obj["xxxx"] # __getitem__
obj["xxxx"] = 123 # __setitem__
del obj['xxx'] # __delitem__
7.__add__ （self,other）
两个对象相加 obj1+obj2 -->obj1.__add__(obj2)
解决程序中哪些不可预知的错误（程序无法考虑的情况）
1.基本格式
-简单粗暴的格式
try:
....
...
except Exception as e:
pass
-错误细分
try:
data = {"k1": 123}
data['k10']
except IndexError as e:
print("index error捕获 -->", e)
except ValueError as e:
print("value error捕获 -->", e)
except KeyError as e:
print("key error捕获 -->", e)
except Exception as e:
print("错误", e)
-特殊的finally，无论成功与否都会执行。（一般用于做资源的释放）
try:
data = {"k1": 123}
print(data)
except Exception as e:
print("错误", e)
finally:
print("结束")
注意：finally遇到函数的return，不会立即返回，而是一定要执行finally中的代码。
def run():
try:
int("内容")
return 123
except Exception as e:
print("错误", e)
return 123
finally:
print("finally")
if __name__ == '__main__':
run()
2.主动触发异常
raise Exception()
def run():
try:
v1 = 123
raise Exception("错误了")
v2 = 456
except Exception as e:
print("错误", e)
if __name__ == '__main__':
run()
3.约束
就是基于异常和面向对象的基类，对子类进行一个约束，
在父类类目写上raise NotImplementedError()
class BaseMessage(object):
def send(self):
raise NotImplementedError() # 子类中必须要实现（重写）次方法。
class DingDingMessage(BaseMessage):
def send(self):
print("发送钉钉的功能")
class WechatMessage(BaseMessage):
def send(self):
print("发送微信的功能")
class SmsMessage(BaseMessage):
def send(self):
print("发送短信的功能")
类似于其他编程语言的：interface - 接口
