Python语法笔记（云端存个档，活用Ctrl+F）

一、字符串独有用法

1.判断开头.startswith

v1.startswith("北京市")#判断v1是否以‘北京市’开头

2.判断结尾.endswith

v1.endswith("羊村")#判断v1是否以‘羊村’结尾

3.判断是否整数.isdecimal

v1.isdecimal()#判断字符串v1是否是纯整数
  #无法对①这样的进行排除"①".isdigit()判定为true

4.去除两(单左右)边空白或特定值.(lr)strip

v1.strip()#去除两边空白,换行符，制表符,lr表示仅去左右
v1.lstrip()
v1.rstrip()
#若()填入"xx"表示去除指定的内容
a1="  111  ".lstrip()
print(a1)

5.大小写转换.upper,lower,title

v1.upper()#全大写
v1.lower()#全小写
v1.title()#每个单词首字母大写


v1.swapcase()#小改大以及大改小
v1.capitalize()#s[0]改为大写

6.内容替换.replace

#其实对于列表也适用
v1.replace("CNM","***")#脏话屏蔽

#评论过滤
char_list={"CMN","CNM","nmsl"}
content=input("请输入评论内容")
for keyword in char_list:
    content=content.replace(keyword,"**")
print(content)

7.字符串切割.®split

v1.split(",")#以“，”为切割标准

#判断用户密码是否正确
info="root,123"
user_list=info.split(",")

user=input("输入用户名")
pwd=input("输入密码")
if user==user_list[0] and pwd==user_list[1]:
    print("正确")
else:
	print("失败")
    
#控制切几个
data="111,222,333"
v1=data.split(",",1)#只切第一个
print(v1)

#从右边开切，最常用的可以用来判别文件类型
address="c/user/desktop/x.yy/1.txt"
v1=address.rsplit(".",1)#只切右边第一个
if v1[-1]=="txt":
    print("文本")
else:     
	print("非文本")
    

8.基于.join的字符串拼接

data_list=["1","2","3"]
v1="<".join(data_list)
print(v1)#1<2<3

9.字符串格式化.format

name="{}喜欢{}，还有{}"
#{}内缺省则默认按照012顺序
data=name.format("我","尼亚","大家")
print(data)

name="{i}喜欢{her}，还有{them}"
data=name.format(i="我",them="大家",her="尼亚")
print(data)

10.字符串存储为字节类型encode

data="123abc你我他"#unicode形式存储
v1=data.encode("utf-8")#编码
v2=v1.decode("utf-8")#解码

11.字符串居中居左居右

print("YJJ".center(21,"*"))#总共21字符，以*填充 YJJ居中
"YJJ".ljust(21,"*")
"YJJ".rjust(21,"*")

12.输入str以此跳转源码查看字符串独有功能

13.字符串测试函数与字符串搜索函数表

函数名	何时返回True
s.endswith(t)	s以字符串t结尾
s.startswith(t)	s以t结尾
s.isalnum()	s只包含字母、数字
s.isalpha()	s只包含字母
s.isdecimal()	s只包含十进制数字的字符
s.isdigit()	s只包含数字字符
s.isidentifier()	s是合法的标志符
s.islower()	s只包含小写字母
s.isnumeric()	s只包含数字
s.isprintale()	s只包含可打印的字符
s.isspace()	s只包含空白字符
s.istitle()	s大小写符合头衔要求的
s.isupper()	s只包含大写字母
t in s	s包含字符串t

函数名	返回值
s.find(t)	如果没有找到t返回-1，否则返回第一个t在s的起始位置
s.rfind(t)	和上述一样，但从右搜索
s.index(t)	同find，但找不到则引发ValueError异常
s.rindex(t)	同上，从右搜索

二、字符串公共功能

1.+号实现拼接

2.*号实现复制

data="发癫"
v1=data*3

3.长度len(data)

data="发癫"
value=len(data)
print(value)

4.索引message[]

#字符串类似于元组，只能检索到不能检索后修改
message="mio, wo de mio, mei you ni wo ke ze me huo a"
length=len(message)-1
while length>=0:
    print(message[length])
    length-=1
#倒序输出

5.切片[:]

#切片最右值不取
message="012345"
print(message[0:2])#s输出01
print(message[:-1])#取到到处第二个截止，不取后

6.步长(负数可倒序输出)[::1]

message="012345"
print(message[::-1])#543210
print(message[::-2])

7.for,while循环(搭配range)

range(2,4,1)#以步长1输出23，前取后不取
range(10)#从，输出0-9
#break 终止当前层循环
#continue 终止本次循环 

三、列表独有功能

1.追加.append

list=range(10)
l=[]
for item in list:
    l.append(item)
print(l)

2.批量追加.extend(配合range)

l=[]
l.extend(range(10))
print(l)#快速批量添加(本质上就是循环传入的每个元素)

#比如我有一个字符串"yjj"，想要把字符串每个字母单独添加进去
l=[]
a="yjj"
for item in a:
    l.append(item)
print(l)
#简单的：
l1=[]
l1.extend(a)

3.指定位置插入.insert

list=["1","2","3","4"]
list.insert(-1001,"0")
print(list)#索引大于列表长度则放入最右，小于长度相反数则放最左

4.删除,清空.remove .pop .clear

#remove删除指定内容一次删一个，没有则报错
list=["yjj","yjj","yjj","y"]
while True:
    if "yjj" in list:
        list.remove("yjj")
    else:
        break
print(list)

#pop默认弹出最后一个，指定为索引位置
list=["yjj","yjj","yjj","y"]
a=list.pop(0)
 

5.根据值找索引.index

list=["yjj","yjj","yjj","y"]
a=list.index("yjj")
print(a)

6.排序.sort sorted()

#本质是用unicode大小排序，可排序任意类型,查询用ord指令。
#v1=ord("y")
list1=[1,234,2,4,2243,1234,241]
list1.sort()#从小到大
print(list1)
list1.sort(reverse=True)#从大到小
print(list1)

#用sorted()不改变原列表，但返回的是迭代器地址，需要list(),和下面reversed相同
list1=[1,234,2,4,2243,1234,241]
a=list(sorted(list1))
print(a)
print(list1)
#仍然可以传递(reverse=True)来从大到小排序

'''sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

sort 只是应用在 list 上的方法（就地排序无返回值）。

sorted 是内建函数，可对所有可迭代的对象进行排序操作，（返回新的list）。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
'''

7.反转.reverse reversed()

list1=[1,234,2,4,2243,1234,241]
list1.reverse()
print(list1)

#不改变原列表
list1=[1,234,2,4,2243,1234,241]
a=reversed(list1)
print(list1)
print(a)#<list_reverseiterator object at 0x0000025776D10760>...据说输出的是迭代器地址？需要用list()方能输出结果
a1=list(a)
print(a1)

四、列表公共功能

1.列表相加相乘

#+ *分别是拼接和copy

2.包含in 和not in

if item in list：
if item not in list：

3.len长度

list1.len()

4.索引,可以读改删

#(建议配合for range使用)如：
list=[1,2,3]
for index in (range(len(list))):
    print(index,list[index])
#字符串也可以索引
user_list=[1,2,3]
print(user_list[0])
user_list[1]=1
del user_list[2]
print(user_list)
user_list.pop(1)
print((user_list))
user_list.remove(1)
print(user_list)

#有一个坑，如果按照某个条件删除，按照索引做循环的时候那么前面删除的会导致索引错误
user_list=["YJJ","JJY","YYY","YYJ","JJJ","YYYY"]
for item in user_list:
    if item.startswith("Y"):
        user_list.remove(item)
print(user_list)
#正确应该如下，倒着去索引
user_list=["YJJ","JJY","YYY","YYJ","JJJ","YYYY"]
for index in range(len(user_list)-1,-1,-1):
    item=user_list[index]
    if item.startswith("Y"):
        user_list.remove(item)
print(user_list)

4.嵌套

#存在嵌套索引
a=["abc",789,111]
print(a[0][1])#输出b
#切记哪怕在嵌套中，字符串依然无法修改，即创建了一个新的字符串，也就是说在列表里操作字符串仍然要用赋值
b=a[0].upper()
a[0]=b
print(a)

#或者a[0]=a[0].upper

五、集合独有功能

1.添加.add

data=set()
data.add("yjj")

2.删除.discard

data={"yjj",1}
data.discard(1)
print(data)

3.交集并集差集

#交集&，并集|，差集-

六、集合公共功能

1.长度len()

2.无索引

3.类型转换

v1="YJJ"
v2=set(v1)
print(v2)#"挨着输出Y,J,J"

#列表去重常用

4.集合元素以哈希表存储，所以必须是可哈希的，且查找很快

#list，set不可哈希
#所以在列表嵌套列表时候，转换成集合会报错

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[];v=list()
tuple	否	是	无	是	tuple(其他)	v=();v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()
dict	是	是	键可哈希，值随意(但值如果是集合，那也应该遵循集合的可哈希)	否	dict(其他)

七、字典独有功能

1.根据键获取值.get()

info={"age":1,
    "status":True,
    "name":"YJJ"}
data1=info.get("name")
data2=info.get("email")#不存在返回None
print(data1,data2)

2.获取键.keys()

#py2得到的是键的列表，而3是得到高仿列表(用于节省内存)，可通过list转
info={"age":1,
    "status":True,
    "name":"YJJ"}
for ele in info.keys():
    print(ele)
if "age" in info.keys():
    print(1)
else:
    print(0)

3.获取值.values()

#同2中的键

4.获取键值对应关系.items()

#输出的是元组，item是(键，值)
info={"age":1,
    "status":True,
    "name":"YJJ"}
for item in info.items():
    print(item[0],item[1])	
    #age 1
	#status True
	#name YJJ
    
    #print(item)
    #('age', 1)
	#('status', True)
	#('name', 'YJJ')
for key, value in info.items():
    print(key,value)

5.设置(新增)值.setdefault()

#如果键存在则无事发生，不存在则新增
info={"age":1,
    "status":True,
    "name":"YJJ"}
info.setdefault("age",18)
info.setdefault("a","b")
print(info)

6.更新键值对.update()

#如果键存在则更新，不存在则新增,注意书写格式和上条不同
info={"age":1,
    "status":True,
    "name":"YJJ"}
info.update({"age":18})
info.update({"a":"b"})
print(info)

7.移除.pop()

info={"age":1,
    "status":True,
    "name":"YJJ"}
data=info.pop("age")
print(data)#输出弹出的值

8.按顺序移除，后进先出.popitem()

info={"age":1,
    "status":True,
    "name":"YJJ"}
data=info.popitem()
print(data)#输出弹出的键和值

八、字典公共功能

1.并集|(python3.9以后)

#类似于update,区别在于得到新的字典
v1={"k1":1,"k2":2}
v2={"k2":3,"k3":5}
v3=v1|v2
print(v3)#{'k1':1,'k2':3,'k3':5}

2.长度len()

3.索引(即使在py3中也不能通过数字取值，而是键)

#和get相似，但不存在则会报错
v1 = {"k1": 1, "k2": 2}
print( v1['k1'] )
# print(v1["k5"])

4.增加，删除del

#新增类似于update
v1 = {"k1": 1, "k2": 2}
v1["k3"]="333"
print(v1)

#没有则报错
v1 = {"k1": 1, "k2": 2}
del v1["k1"]
print(v1)

5.for循环

6.转换

v=dict([["k1","v1"],["k2","v2"]])
print(v)

九、文件操作

1.读文件"wb",“wt”

#判断路径是否存在
import os
file_path='C:/Users/YJJ/Desktop/pythonProject/1.txt'
exists=os.path.exists(file_path)
if exists:
    print(exists)
#编码和解码
name="YJJ"
data=name.encode('utf-8')#编码
print(data)
a=data.decode('utf-8')
print(a)#解码

'''
#1.打开文件
file_object=open('1.txt',mode="rb")#第一个参数相对地址，也可使用绝对地如：
'C:/Users/YJJ/Desktop/pythonProject/1.txt'
#2.读取文件内容，赋值给data
data=file_object.read()
#3.关闭文件
file_object.close()
print(data)#二进制
#解码
text=data.decode('utf-16')
print(text)
'''

#简单的做法
file=open( 'C:/Users/YJJ/Desktop/pythonProject/1.txt',mode='rt',encoding='utf-16'
)
file_read=file.read()
print(file)
print(file_read)

2.写文件"rb",“rt”

'''
#1.打开文件
file_object=open('1.txt',mode="wb")#第一个参数相对地址，也可使用绝对地如：
'C:/Users/YJJ/Desktop/pythonProject/1.txt'
#2.读取文件内容，赋值给data
file_object.write("YJJ".encode('utf-8'))
#3.关闭文件
file_object.close()
'''

#简单做法
file_object=open('1.txt',mode="wt",encoding='utf-8')
file_object.write("111")#必须字符串，否则报错
file_object.close()

3.打开模式分析’r,w,x,a’ ‘t,b’ ‘+’ (包括光标位置)

• 只读：r,rt,rb

  • 存在，读
  • 不存在，报错
  • r=rt,需要注意设定编码，没有默认为utf-8

• 只写：w,wt,wb

  • 存在，清空再写
  • 不存在，创建报错

• 只读：x,xt,xb

  • 存在，报错
  • 不存在，创建再写

• 只写：a,at,ab

  • 存在，尾部追加
  • 不存在，创建再写

• 读写:+(取决于光标位置)

  • r+=rt+,默认光标位置写，注意是覆盖写，如果先写后读，光标位置在文本首，使得最开始内容被覆盖

  • w+=wt+,光标位置在起始位置，因为会清空文件。所以最开始读为空，先写由于光标始终后移，所以依然读不到，可利用如下语句

    file_object.seek(0)
    #将光标位置移动到起始，注意数字是指字节数，utf-8三字节一个汉字，注意乱码且对于a无效，a每次都是移到最后写
    
    #显示光标位置
    f.tell()
    

  • a+=at+,打开后光标在最后,且不管怎么移动。写之前总会移动到最后

4.以行为单位读.read() .readline()

#t模式读字符，b读字节
f=open('1.txt',mode="rt",encoding='utf-8')
data=f.read(1)#读一个字符
print(data)


#.readline()一行一行的读，只读第一行但不太方便，

#.readlines()一行一行读，形成列表，每一行一个元素

#想要一行一行输出
f=open('1.txt',mode="rt",encoding='utf-8')
for line in f:
    print(line.strip())#本身换行以及循环给了一个换行
f.close

5.将缓冲区刷到硬盘

#写到缓冲区，不定时转移到数据大量数据更新不及时，则可用.flush()
f=open('1.txt',mode="at",encoding='utf-8')
while True:
    f.write("YJJ")
    f.flush()
f.close()

6.with open

with open('1.txt',mode="at",encoding='utf-8') as f:

7.文件分割实例(copy某大佬的，具体链接忘了)

import os

sourceFileName = "1.txt"  # 定义要分割的文件


def cutFile():
    print("正在读取文件...")
    sourceFileData = open(sourceFileName, 'r', encoding='utf-8')
    ListOfLine = sourceFileData.read().splitlines()  # 将读取的文件内容按行分割，然后存到一个列表中
    n = len(ListOfLine)
    print("文件共有" + str(n) + "行")
    print("请输入需要将文件分割的个数:")
    m = int(input(""))  # 定义分割的文件个数
    p = n // m + 1
    print("需要将文件分成" + str(m) + "个子文件")
    print("每个文件最多有" + str(p) + "行")
    print("开始进行分割···")
    for i in range(m):
        print("正在生成第" + str(i + 1) + "个子文件")
        destFileName = os.path.splitext(sourceFileName)[0] + "_part" + str(i) + ".log"  # 定义分割后新生成的文件
        destFileData = open(destFileName, "w", encoding='utf-8')
        if (i == m - 1):
            for line in ListOfLine[i * p:]:
                destFileData.write(line + '\n')
        else:
            for line in ListOfLine[i * p:(i + 1) * p]:
                destFileData.write(line + '\n')
        destFileData.close()
    print("分割完成")


if __name__ == "__main__":
    cutFile()

# -*- coding: utf-8 -*-

# 按照大小分割文件

import os

filename = "1.txt"  # 需要进行分割的文件，请修改文件名
size = 80000  # 分割大小约80K


def mk_SubFile(srcName, sub, buf):
    [des_filename, extname] = os.path.splitext(srcName)
    filename = des_filename + '_' + str(sub) + extname
    print('正在生成子文件: %s' % filename)
    with open(filename, 'wb') as fout:
        fout.write(buf)
        return sub + 1


def split_By_size(filename, size):
    with open(filename, 'rb') as fin:
        buf = fin.read(size)
        sub = 1
        while len(buf) > 0:
            sub = mk_SubFile(filename, sub, buf)
            buf = fin.read(size)
    print("ok")


if __name__ == "__main__":
    split_By_size(filename, size)

8.excel操作

#pip install openpyxl

from openpyxl import load_workbook as lw
wb=lw("1.xlsx")
#1.获取所有sheet名称，并选择行列
print(wb.sheetnames)
sheet=wb["xxxx"]#选择sheet名称，索引位置也可，如：
#sheet=wb.worksheets[0]
cell=sheet.cell(1,2)#第一行第二列，返回的是元组,此语句等价于：
#cell=sheet['A2']
print(cell.value)#文本信息
#cell.style
#cell.font
#cell.alignment

#3.第N行所有单元格
for cell in sheet[1]:
    print(cell.value)
#4.所有行
for row in sheet.rows:
    print(row[0].value,row[1].value)
#5.所有列
for col in sheet.columns:
    print(col[0].value,col[1].value)

十、函数

1.基本结构

def func(arg):
    pass

name()

2.参数

def get_lsit(aaa):
    v=[11,22,33,44]
    print(v[aaa])

get_lsit(1)

3.返回值

#函数一旦遇到return，则后续不执行

def func(arg):
    #pass
    return 9#默认return None

val=func('aasdasda')#val=9

#统计A个数
def get_char_count(data):
    sum_counter = 0
    for i in data:
        if i == "A":
            sum_counter += 1

    return sum_counter
a = get_char_count('aADAFAAFAF')
print(a)

4.函数实例

# 1.判断列表数字个数
def num(number):
    count = 0
    for i in number:
        if type(i) == int:#判断是否是数字
            count += 1
    return count

print(num([1, 1312, 11, 'ddff', 'wfew']))

5.传参可设置默认值

def func(a1,a2=9):
    pass
#不传默认为9，且位置传参关键字传参在位置传参后面

func(1,a2=1)#可
func(a1=1,8)#不可

6.函数参数*,**表示可变的参数个数生成元组，字典

def func(*args):#规范写法
    print(a1)
#*只支持位置传参
func(1)
func(1,2)
func((11,22,33))
func(*(111,222,333))
# (1,)
# (1, 2)
# ((11, 22, 33),)
# (111, 222, 333)输出元组


def func(**kwargs):
    print(kwargs)

func(k1=1,k2="YJJ")

#输出字典{'k1': 1, 'k2': 'YJJ'}
func(**{'k1':1, 'k2': 'YJJ'})

7.作用域

#python以函数为一个单独作用域
#作用域查找规则：优先在自己查找，自己没有再去父级找，直至找到全局，全局没有就报错

def func():
    x=9
    print(x)
print(x)#报错

#子作用域只能查找父作用域的内容，不能重新赋值
#非要赋值，需要  global x
name=[111,23,34]
def func():
    global name
    name=1
func()
print(name)
，使用
#或者修改上一级 nonlacal x

8.函数赋值,融入列表，集合，字典中等

def func():
    print(1)
v1=func
v1()

func_list=[func,func,func]
func_list[1]()

9.lambda表达式 λ(偷懒的函数定义，可结合map，filter，reduce使用),又称匿名函数

def func(a1,a2):
    return a1+a2

func2=lambda a1,a2:a1+a2
#默认会返回a1+a2

10、内置函数

1.进制转换

#abs()绝对值

#divmod(a,b)返回两数商和余数
x,y=divmod(1001,5)
print(x,y)#200 1

#bin()十转二0b1111
#oct()十转八0o7777
#hex()十转十六0xAAAA
#int()其他转十
v1="0o1101"
result=int(v1,base=8)

2.编码相关

#chr()将某个十进制转化成unicode编码中对应的字符串
#ord()上述反之

3.随机

import random
random.randomint(1,3)#1到3中随机

4.map()输入x，输出x+100

#map(lambda,v1)第二个参数是可迭代的(可以for循环的)，第一个是函数。循环第二个参数然后将返回值添加到一个列表中。不影响原参数的值，只是循环。

#py2中map会返回这个列表，而py3中则会返回一个可迭代对象，(大致意思是map没有立刻运行，以起到节省内存作用(也许是调试方便点？存疑)),用list()可以转换这个参数
v1=[11,22,33,44]
print(map(lambda x:x+1000,v1))
#py3结果<map object at 0x0000016231E46AF0>
#py2结果[1011, 1022, 1033, 1044]

print(list(map(lambda x:x+1000,v1)))
#py3结果[1011, 1022, 1033, 1044]

5.filter()输入x，输出筛选过的x(根据返回值T或F)

v1 = [11, 22, 33, 44, "adafdaf"]
print(list(filter(lambda x: type(x) == int, v1)))
#已经有TF返回值了，等价于
print(list(filter(
    lambda x: True if type(x) == int else False, v1)
          )
     )

6.reduce()输入x，输出x中元素操作后得到的返回值

#reduce需要两个参数，初始是x的一二个元素，第二次迭代是上一次迭代返回值和下一次进行运算
import functools as ft

v1 = [1, 2, 3, 4, 5, 6]
print(ft.reduce(lambda x, y: x + y, v1))

十一、装饰器(另有带参数的，暂时跳过)

#装饰器目的是在不修改原函数内部代码的基础上，做一些小修补

#标准格式为
def func(arg):#arg为被装饰的函数
    def inner():
        print("before index")
        #修饰index执行前
        
        v=arg()
        
        print("after index")
         #修饰index执行
        return v
    return inner

@func
#@执行index=func(index)
def index():
    print("123")
    return 666
index()

#例如我们想用来计算函数运行时间
import time

def delta(arg):
    def inner():
        print("before index")
        #修饰index执行前
        strat_time=time.time()
        v=arg()
        end_time=time.time()
        print(end_time-strat_time)
        print("after index")
         #修饰index执行
        return v
    return inner

@delta
def index():
    print("123")
    time.sleep(2)
    return 666
index()

十二、迭代器

1.列表等转换成迭代器

v1 = [1, 2, 3]
v2 = iter(v1)#转换成可迭代对象，或v1.__iter__()
while True:
    try:
        val = v2.__next__()  # 或者next(v2)
        print(val)
    except Exception as e:
        break
  

十三、生成器

1.类似于函数的变种，函数内部包含yield

def func():
    print("第一次")
    yield 2#返回2
    print("第二次")
    yield 3
    print("第三次")
    yield 100
    print("第四次")


# 函数内部代码不会执行。返回一个生成器对象
v1 = func()
# 生成器是可以被for循环的,一旦开始循环内部代码开始执行

for item in v1:
    print(item)#输出返回值

#存在yield该函数是生成器函数，调用生成器函数返回一个生成器，被for循环时开始调用，每次得到yield的返回值，注意item只拿yield的值，原函数遇到return直接终止，因此可以以此作为终止条件

十四、类

1.基本格式

#类中的函数叫做方法，类名第一个字母大写
class Account:
    def func(self, name):  # 第一个形参必须加self(self是约定，也可其他)
        print(name)
        return 0


x = Account()
x.func("name")

2.初始化，封装

class Person:
    def __init__(self, n='yjj', a=1, g='男'):
        # 初始化方法(构造方法)，给对象内部做初始化
        self.name = n
        self.age = a
        self.gender = g

    def show(self):
        temp = '我是%s,年龄：%s,性别：%s' % (self.name, self.age, self.gender)
        print(temp)
        return 0


# 类()实例化对象，自动执行一次类中__init__方法。

p1 = Person()
p2 = Person("铸币", 18, "女")
p1.show()
p2.show()

3.继承

# 父类(基类)
class Base:
    def f1(self):
        pass


# 子类(派生类)
class Foo(Base):
    def f2(self):
        pass


obj = Foo()
# 执行对象.方法时,优先在子类找，找不到再去父类，父类不能去子类找
obj.f2()
obj.f1()


#python3中默认继承的都是object类，开辟内存空间

class Foo:
    pass

class Foo(object):
    pass
#两者等价

#节省代码.可以把两个类公共的功能放入一个base中，然后各自派生

#python支持多继承，Foo(Base1,Base2),调用方法先从左边的找，支持多继承的有C++，JAVA和C#均不支持

注意事项：

• 时刻清醒self是谁？

• 初始化创建哪一类，就从哪一类优先去找。

class Base:
    def f1(self):
        self.f2()
        print('base.f1')
    def f2(self):
        print('base.f2')
class Foo(Base):
    def f2(self):
        print('foo.f2')
obj=Foo()
obj.f1()
#输出为foo.f2 base.f1

4.多态(多种形态、多种类型)鸭子模型

#python对于函数方法传参没有限制，可以是各种类型，但类中有使用某些方法例如arg.send，那么就对于传入类型有一个限制(必须要有send方法)

#我们认为只要嘎嘎叫的就是鸭子(只要有send方法的就是我们要的合法类型)，JAVA则不行

三大特性总结

• 封装：将相近的方法聚在一起

• 继承：从左边起寻找，可以多继承

• 多态：鸭子模型

  def func(arg):#多种类型，很多事物
      arg.send()#必须要有send方法
  

5.绑定方法和静态方法

#在类下面的一般方法称为绑定方法
class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):#由于没有用到self，pycharm会提示你创建为函数或者加上静态修饰器
        print(a, b)

    @staticmethod
    #Python内置的修饰器，可以不创建对象直接调用类里面的方法，相当于函数
    def f1():
        print(23)


obj = Foo()
obj.func(1, 2)

Foo.f1()
#绑定方法@staticmethod，参数无限制
#调用 类.方法名()
#或者 对象.方法名() 不推荐

6.类方法(静态方法的衍生)

# 加修饰器@classmethod
class Foo:
    def __init__(self):
        self.name = 123

    @classmethod
    def f2(cls, a, b): 
        # cls表示当前类，必须要有，其余参数无所谓
        print('cls是当前类', cls)


Foo.f2(1, 2)#输出：cls是当前类 <class '__main__.Foo'>

7.属性

对象.方法 不用加括号

# 加修饰器@classmethod
class Foo:
    def __init__(self):
        self.name = 123

    @property
    def f2(self):
        print('属性')


obj = Foo()
obj.f2

8.成员修饰符

变量前加’__'会使得其变成私有，只有类内部方法可以访问，外部不行，同时方法前面也可以加,同时甚至子类都不能访问

class Foo:
    def __init__(self, name='yjj'):
        self.__name = name

    def func(self):
        print(self.__name)


obj = Foo()
obj.func()#输出yjj
obj.__name#找不到__name       

9.强制访问私有

class Foo:
    def __init__(self, name='yjj'):
        self.__name = name

    def func(self):
        print(self.__name)


obj = Foo()
print(obj._Foo__name)#_类名__

10.类中的特殊方法(typora中想要打出双下划线需要前后加``)

__new__ __init__ __call__

class Foo(object):
    def __new__(cls, *args, **kwargs):
        print("已创建空对象")
        return object.__new__(cls)

    '''
    用于创建空对象，构造方法，默认继承的object开辟内存，然后默认调用new，因此可以不用写此类方法
    '''

    def __init__(self):
        print("已初始化")

    '''
    初始化对象
    '''

    def __call__(self):
        print("执行call方法")


obj = Foo()
obj()  # 对象加括号执行call方法


class Foo:
    def __new__(cls, *args, **kwargs):
        print("已创建空对象")
        return object.__new__(cls)

    '''
    用于创建空对象，构造方法，默认继承的object开辟内存，然后默认调用new，因此可以不用写此类方法
    '''

    def __init__(self):
        print("已初始化")

    '''
    初始化对象
    '''

    def __call__(self):
        print("执行call方法")


obj = Foo()
obj()  # 对象加括号执行call方法

__getitem__ __setitem__ __delitem__ 类似于字典用法

class Foo(object):
    def __setitem__(self, key, value):
        pass

    def __getitem__(self, item):
        pass

    def __delitem__(self, key):
        pass


obj1 = Foo()
obj1['k1'] = 123  # 内部调用setiterm,并且传参key为k1,value为123
obj1['xxx']  # 内部调用getitem
del obj1['ttt']  # 内部调用delitem

__str__

class Foo(object):
    def __str__(self):
        return "yjj"

    """
    只有在打印时才会自动调用此方法，且打印一个返回值
    """


obj = Foo()
print(obj)

__dict__

将对象里的属性转换成字典

__iter__

转换成可迭代对象

11.约束

拾遗

1.is判定内存地址是否一致

v1=[]
v2=[]
print(v1 is v2)#不在一个内存

v1=None
v2=None
print(v1 is v2)#True,同一内存，可以节省一点内存

2.位运算

#&与运算
#|或运算
#^异或
#~取反
#<<左移1位等价于乘2
#>>右移1位等价于除以2

3.pass，什么都不干，保持语法完整性

4.文件路径相关

import os
#获取当前py脚本所在路径
abs=os.path.abspath(__file__)#—__file__前后两个下划线
#找上一级目录
path=os.path.dirname(abs)

#集成
base_dir=os.path.dirname(os.path.abspath(__file__))
print(base_dir)
#这种函数拼接可以自适应，根绝不同系统判断加\还是/，可以无限拼接，逗号隔开
file_path=os.path.join(base_dir,'files.txt')
print(file_path)

#判断路径是否存在
if os.path.exists(file_path):
    print("YES")
else:
    print("NO")
 
#

5.内存相关(施工中P60)

b站视频

6.time.sleep()

import time
time.sleep(1)#线程挂起1秒，https://www.runoob.com/python/att-time-sleep.html

7.推导式

1.列表推导式

v1 = [i for i in 'alex']

v2 = [i + 100 for i in range(10)]

v3 = [lambda: i for i in range(10)]
print(v3[4]())  # 循环完后i=9，所以v3[any]()=9

v4 = [lambda x: x * i for i in range(10)]
print(v4[0](2))  # 18

2.集合推导式

v1 = {i for i in "alex"}
print(v1)

3.字典推导式

v1 = {'k' + str(i): i for i in range(10)}
print(v1)

4.字典去重实例(copy某大佬)

from functools import reduce

ll = [
        {
            "name":"1",
            "no":"2"
        },
        {
            "name": "1",
            "no": "2"
        },
        {
            "name": "2",
            "no": "3"
        }
    ]

func = lambda x, y: x if y in x else x + [y]
ll = reduce(func, [[], ] + ll)
print(ll)  # [{'name': '1', 'no': '2'}, {'name': '2', 'no': '3'}]

8.默认参数可变时产生的陷阱

def func(a, b=[]):
    b.append(a)
    return b


l1 = func(1)
l2 = func(2, [11, 22])
l3 = func(2)
print(l1, l2, l3)

#空列表在没有传入参数时默认开辟一块内存，但每个不传参的调用都指向同一块内存

9.sys解释器系统模块(施工中)

import sys
sys.stdout.write('123')#print()

10.print(xxx,end=‘’)以什么结尾,以\r回到当前行的起始位置

import time
for i in range(1,101):
    msg="%s%%\r"%i
    print(msg,end='')
    time.sleep(0.5)
#类似于进度条    
    

11.异常处理

#在任意地方填下如下代码，可以不报错终止程序
try:
    pass
except Exception as e:
    pass
#实例
def func(a):
    try:
        return a.strip()
    except Exception as e:
        return False


v = func('     alex     ')
if not v:
    print("执行失败")
else:
    print("结果是:", v)
    
    
    #捕获多种异常
    def test(a,b):
        try:
            return int(a,b)
        except(ValueError,TypeError):
            return 'error'
    #分情况 
    def test(a,b):
        try:
            return int(a,b)
        except ValueError:
            return 'value error'
        except TypeError：
        	return 'type error'
        	
   #捕获所有
	def test(a,b):
        try:
            return int(a,b)
        except:
            return 'error'
        
        
	def test(a,b):
        try:
            return int(a,b)
        except:
            return 'error'
        finally:
            print('a')
            #不管try还是except执行，finally语句都会在最后执行。可用于关闭文件等操作

12.//表示整除，返回值是精准值的整数部分(非四舍五入)

13.round()四舍五入

'''
python将.5如8.5,9.5这类取整到最接近的偶数上，前者为8，后者为10，而不是统一向上取整
'''
print(round(8.5))
print(round(9.5))

14、正则表达式可以通过查询re库解决，CSDN收藏

import re