Python

Python

未完 待续……

基础语法

1.跨平台 面向对象 解释型编程语言

2. 模块单导入，行结尾不加分好

3. 命名规范：组件小写，类骆驼，常量名大写，类的属性和方法小写

   1.项目名称
   首字母大写+大写式驼峰，
   ProjectName
   
   2.模块名和包名
   全部小写+下划线驼峰
   module_name  package_name
   
   3.类名称，异常
   首字母大写+大写式驼峰，
   class ClassName:   ，ExceptionName
   
   4.全局变量、常量
   全部使用大写字母+下划线驼峰
   GLOBAL_VAR_NAME，CONSTANT_NAME
   
   5.方法名，函数名，其余变量，参数，实例
   全部小写+下划线驼峰
   method_name，function_name，instance_var_name, function_parameter_name, local_var_name
   
   6.处理计数器外，不使用单字母命名
   

4. 使用下划线“_”开头的模块变量和函数是受保护的，不能变量导入，表示不能直接访问的类属性

5. 使用双下划綫“__”的变量和方法是类私有的，是类的私有成员

6. 以双下划綫开头和结尾是Python的专用标识 __init__()标识构造函数

注释

​ #

​ ‘’‘……’‘’

​ ‘’‘‘’‘……’‘’’‘’

变量

变量命名

​ 慎用小写字母l和大写字母O

​ 允许多个变量指向同一个值（享元，节约内存，和C#中string 类似）

​

#在Python中，整数和短小的字符(不含空格)，Python都会缓存这些对象，以便重复使用
True
a = 1
b = 1
print(a is b)

# True
a = "good"
b = "good"
print(a is b)

# False
a = "very good morning"
b = "very good morning"
print(a is b)

# False
a = []
b = []
print(a is b)

1、Python缓存了整数和短字符串，因此每个对象在内存中只存有一份，引用所指对象就是相同的，即使使用赋值语句，也只是创造新的引用，而不是对象本身；
　　2、python对于字符串来说，如果不包含空格的字符串，则不会重新分配对象空间，对于包含空格的字符串则会重新分配

数字类型（整数，浮点数，复数）

​ 不可变性（和C# string 类似）；当给一个数字类型修改变量时，先开辟一个内存空间，放置这个值，然后再讲这个数字变量指向这个内存地址

整数：位数无限制，数比较大时会在数字后自动加上l或L（2.x版本）,十进制不能以0开头，0除外

​ 八进制数：以 0o开头 或 0O开头（3.x）,在 2.x可以以 0 开头

​ 十六进制：0x 或 0X开头

字符串：

​ 不可变性

​ 用’’,"",’’’ ‘’’,""" “”"包含

​ 转义字符 \

​ 取消\转义 r或者R，和C# @类似

布尔

​ 所有对象都可以进行真值测试

运算符

​ // 取整 7//2 为3

​ ** 幂 2**4 为16

​ 逻辑运算符 用and or not ，位运算和C# 一样

​

条件表达式(没有括号，有冒号)

if a<b:
	...
else:
	...

while none:
	...

for a in range(1,10,2):  		# 和C# foreach类似，还可以遍历字符串，用来输出字符

	print(i,end='-')  #表示按一行输出1-3-5-7-9; #end='' 用来定义分隔符 Python 3.x;python 2.x 用 print(i, )表示

continue ,break 和c#用法一致

pass 是一个占位符，不做任何事情，可留做以后做修改

eg:

​

for i in range(1,10):
		if i%2==0:
			print(i,end=' ')
		else
			pass      #占位符，不做任何处理，方便以后对不是偶数的数进行处理

序列

​ 连续内存空间，按一定顺序排列，每一元素分配一个索引

​ 含：列表，元组，集合，字典，字符串。集合和字典不支持索引，切片，相加和相乘

序列运算

**索引 **

​ 可以为负数，表示 从右 至左，负数起始值为 -1 ，表示最后一个元素。从左至右，起始值为0**

**切片 **

​ 表示获取一定范围内的元素 sname[start : end : step]** #包含start,不包含end

strarr=["abc0","def1","dgd2","dsgs3","sdf4","dffas5","cgs6","ujy7","jhkf8"] 
a1=strarr[2]  
a2=strarr[-1] 
	 print(a1) #dgd2
	 print(a2)  #jhkf8
for s in strarr[1:7:2]: 
	print(s,end=' ') 	#输出def1 dsgs3 dffas5  
print('\n') 
for s in strarr[:8:3]: 
	print(s,end='-')  #输出abc0-dsgs3-cgs6- 
print('\n')        
asfs=strarr[:] #表示复制整个序列
 for s in asfs:
	 print(s,end=',')  #输出abc0,def1,dgd2,dsgs3,sdf4,dffas5,cgs6,ujy7,jhkf8, 

序列相加：

​ 将俩个 相同类型 序列合并，不会去除重复项，相同类型是指同为列表，元组，字符串，而不是指元素类型相同

​ arr1=arr2+arr3

 strarr1=[1,2,3]
 print(strarr+strarr1)  
 #输出abc0,def1,dgd2,dsgs3,sdf4,dffas5,cgs6,ujy7,jhkf8,['abc0', 'def1', 'dgd2', 'dsgs3', 'sdf4', 'dffas5', 'cgs6', 'ujy7', 'jhkf8', 1, 2, 3] 

序列乘法：

​ 示将其中的元素再依次重复出现多少次，可用于初始化序列长度

判断包含 in

​ print(“testin” in strarr1) #false

​ print(“testin” not in strarr1) #true

​

​

​ len(strarr1) 获取长度

​ max(strarr1) 最大值，元素要同类型

​ min(strarr1)最小值

​ sum(整数序列)求和

​ str(),list() 序列类型转换

​ sorted(strarr1),reversed(strarr1)：正序和倒序

​ enumerate() 将序列组合为一个索引序列，多用在for循环中

​ arr=[“sdf”,“ewr”,“Rty”]

​ for index,item in enumerate(strarr1):

​ print(index,item) # eg: 0 sdf ……

添加，修改，删除列表元素

​ strarr1.apend(“abc”) strarr1.insert(1,“abc”) strarr1.extend(arr) strarr1.pop()

​ 添加

​ apend表示在末尾添加，insert 在指定索引处添加，效率没apend高，一般不推荐使用。extend 和序列+运算一样，将一个列表全部添加进去,.pop表示弹出最后一个元素。

​ 修改

​ 直接用=重新赋值

​ 删除

​ del strarr1[1] 删除指定索引的元素

​ del strarr1删除整个列表，一般不用，自带垃圾回收

​ strarr1.remove(“abc”)，删除值为abc的元素，如果不存在会报错，通常用strarr1.count(“abc”)>0判断是否存在

列表其它计算

​ strarr1.count(“abc”)>0 #返回true 表示abc在strarr1中

​ strarr1.index(“abc”) #返回首次出现的索引

​ sum(listname[,start]) #计算数值列表的和，start表示统计结果从哪个数开始，默认为0 ，相当于是listname的和加上start的值

​ sort(key=none,reverse=false) key提取的比较键，reverse表示是否倒序.中文排序不支持

arr=[1,3,4,2,45]	
s1=sum(arr)
s2=sum(arr,2)
print（s1,s2）  # 55 57

char=['cat','Tome','Angela','pet']
char.pop() #弹出最后一个元素
schar=char.sort()   #sort 无返回，列表顺序变化
print(schar,char)   #None ['Angela', 'Tome', 'cat', 'pet']
char.sort(key=str.lower,reverse=True)
print(char)		#['Tome', 'pet', 'cat', 'Angela']
print(sorted(char,key=str.lower,reverse=False)) 
#sorted有返回一个排序后的副本，不会改变原列表 ['Angela', 'cat', 'pet', 'Tome']
print(char)		#['Tome', 'pet', 'cat', 'Angela']

列表推导式

​ newlist=[expresion for var in list]

any = [random.randint(10, 100) for i in range(10)]
print(any)
newchar=[x+"test" for x in char]
print(newchar)
newfilter=[x for x in char if len(x)>3]
print(newfilter)

元组

​ 有序，不可变

​ 和列表相比，元组是不可变序列，元素不可以单独修改；列表是可变序列，元素可随意修改；

​ 元组用（）定义，也可以省略，每个元素用,隔开；列表用[]定义，不可省略。若元组只有一个元素，则这个元素要跟一个“，”，不然会被解析成字符串

import random
char = ['cat', 'Tome', 'Angela', 'pet']
char.pop() #弹出最后一个元素
print(char)
schar = char.sort()  # sort 无返回
print(schar, char)  # None ['Angela', 'Tome', 'cat', 'pet']
char.sort(key=str.lower, reverse=True)
print(char)
any = (random.randint(10, 100) for i in range(10))
print(any)
newchar=(x+"test" for x in char)
print(newchar)
newfilter=(x for x in char if len(x)>3)
print(newfilter)

元组比列表的访问和处理速度快

列表不能作为字典的键，而元组可以

字典

​ 可变，键值对，键不可变，任意类型，任意嵌套，无序

dictionary = {'name': 'kcs', 'age': 30, 'sex': '男', "address": "深圳"}  # 创建字典
print(dictionary['name'])	#kcs
dicEmpty = {}  # 空字典创建
dicEmpty1 = dict()
print(dicEmpty, dicEmpty1) 	#{} {}

listname = ['A', 'B', 'C']
listshow = ('s', 'd', 'e')
zipt = zip(listname, listshow)  
# zip 将俩个列表或元组，组合成元组，并返回包含这些对象的zip对象,可用tuple转化为元组
print(zipt)		# <zip object at 0x000000000253E800>
print(zip(listname, listshow))		# <zip object at 0x00000000024F2900> ！主要这俩个对象不一样需回头了解原因
print(tuple(zipt))	(('A', 's'), ('B', 'd'), ('C', 'e'))
dic = dict(zipt)  # dict和zip配合生成字典，
print(dic)		# {}	！需回头了解原因
print(dict(zipt))	#	{}	
print(dict(zip(listname, listshow)))	# {'A': 's', 'B': 'd', 'C': 'e'}
print(dic)	

dictdemo = dict(a='1', b=2)  # 键不用引号
print(dictdemo) #	{'a': '1', 'b': 2}

lst = ['tp', 'sd']
dicnone = dict.fromkeys(lst)  # dict.fromkeys创建值为none的字典
print(dicnone)	#{'tp': None, 'sd': None}

tstuple = ('asf', 'asf', 'test')
listDemo = ["sf", "rte", "te"]
dicTtt = {tstuple: listDemo}
print(dicTtt)	#	{('asf', 'asf', 'test'): ['sf', 'rte', 'te']}
print(dicTtt[tstuple]) 	#	['sf', 'rte', 'te']

dictionaryDemo = {'name': 'kcs', 'age': 30, 'sex': '男', "address": "深圳"}
if 'name' in dictionaryDemo:
    print(dictionaryDemo.get('name'))  # Python推荐用get	kcs
    print(dictionaryDemo['name'])	#	kcs
a = dictionaryDemo.pop('age')  # 删除指定键，并返回值

print(a)	# 30
dictionaryDemo.popitem()  # 删除最后一项
del dictdemo
dicTtt.clear()
print(dicTtt)	#	{}
dictFor = {'name': 'kcs', 'age': 30, 'sex': '男', "address": "深圳"}

for item in dictFor:
    print(item,end=" ")  # 输出键值 name age sex address
for item in dictFor.items():
    print(item,end='')  
	# 输出键值对('name', 'kcs') ('age', 30) ('sex', '男') ('address', '深圳')
for index, value in dictFor.items():
    print(index, value,end=' ')  # 输出键和value name kcs age 30	sex 男 address 深圳

dictFor["tel"]=1856566  #添加
dictFor["address"]="szlg"   #修改
del dictFor['age']  #删除，不存在时报错
print(dictFor)	# {'name': 'kcs', 'sex': '男', 'address': 'szlg', 'tel': 1856566}

字典推导式

dicRandom={i:random.randint(10,100) for i in range(1,5)}

print(dicRandom)	#	{1: 82, 2: 40, 3: 46, 4: 10}

name=['a','b','c']

age=[12,23,34]

dicZip={i:str(j)+"岁" for i,j in zip(name,age)}

print(dicZip)	#	{'a': '12岁', 'b': '23岁', 'c': '34岁'}
dicIf = {i: j for i, j in dicZip.items() if j == '23岁'}
print(dicIf)	#	{'b': '23岁'}

集合

​ 不重复 可变集合&不可变集合

setDemo = {1, 2, 3, 5, 1, 5, 23}
print(setDemo)  # {1, 2, 3, 5, 23}

setDemo1 = set("集合测试")
print(setDemo1) #{'测', '试', '集', '合'}
print(set())  # 不能用{}表示空集合，{}表示空字典  #set()
tupleDemo=('asdf', 'fd', 'ert')
set1=set(tupleDemo)
print(set1)  #{'ert', 'fd', 'asdf'}
set1.add("add")
print(set1) #{'ert', 'add', 'fd', 'asdf'}
set1.remove('asdf')
print(set1)     #{'ert', 'add', 'fd'}
set1.pop()
print(set1) #{'add', 'fd'}
set1.clear()
print(set1) #set()

set1={'ert', 'add', 'fd', 'asdf'}
set2={'add','muti'}
print(set1&set2)    #{'add'}
print(set1-set2)    #{'ert', 'fd', 'asdf'}
print(set1|set2)    #{'add', 'muti', 'ert', 'fd', 'asdf'}
print(set1^set2)    #{'muti', 'ert', 'fd', 'asdf'}

内存管理

**Python中的变量都是指针，这确实和之前学过的强类型语言是有不同的。**因为变量是指针，所以所有的变量无类型限制，可以指向任意对象。指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。

Python 的所有**变量其实都是指向内存中的对象的一个指针，所有的变量都是！此外，对象还分两类：一类是可修改的，一类是不可修改的。我的理解是把可修改(mutable)的类型叫做值类型，不可修改(immutable)类型叫做引用类型。**

对象=确定内存空间+存储在这块内存空间中的值。

在Python中，数值（整型，浮点型），布尔型，字符串，元组属于值类型，本身（内存地址）不允许被修改（不可变类型），数值的修改实际上是让变量指向了一个新的对象（新创建的对象），所以不会发生共享内存问题。 这种方式同Java的不可变对象（String）实现方式相同 。

1. Python在底层做了一定的优化，对于使用过小整数以及短字符串都会被缓存起来。Python中会为匿名列表对象和匿名字典对象以及短字符串创建缓存区

2. 之所以采用这种优化的方式，是因为python中数字和字符串一经创建都是不可修改的。所以不会出现，因使用了缓存的对象值造成“脏读”的问题

fd = 3.12
print(type(fd))
fd1 = 3.12
print(id(fd), id(fd1))  # 41491216 41491216
tuple1 = ('sdf', 23, 43)
tuple2 = ('sdf', 23, 43)
print(id(tuple1), id(tuple2))  # 40848768 40848768
# 不可变类型的享元，如上所示，相同值是共享同一内存地址的.
# 不可变类型的值是不可变的，是指其内存地址不可变，但如果改变不可变对象其中子对象的值，其子对象元素的地址没有变化，则是合法的,如下
tuple3= ('adf', 234, 54, ['asf', 34])
#tuple3[0]='34'  # 改变了地址: 'tuple' object does not support item assignment
tuple3[3].append('test')
print(tuple3)   #('adf', 234, 54, ['asf', 34, 'test'])

list01 = ['a', 'b', 'c']
list01[0] = ['A', 'B']
print(list01)  # [['A','B'],'b','c']
# 将右边列表的值赋值给list01的第一个位置
print(list01[1:3])
list01[1:2] = ['哪吒']
# 序列赋值
# name,age = ['shibw',18]
# print(name,age)
print(list01)  # [['A','B'],'哪吒','c']

list02 = list01[::-1]
print(list02)  # ['c','哪吒',['A','B']]
print(list01 is list02)  # False
print(id(list01))  # 41801472
print(id(list02))  # 41622848

list02.insert(0,5)
print(list02)   # [5, 'c', '哪吒', ['A', 'B']]
print(id(list01[0]))  # 41931904
print(id(list02[-1]))  # 41931904
print(id(list01[1]))  # 39551600
print(id(list02[-2]))  # 39551600
print(list01[0] is list02[-1])  # True
# 可变类型的地址不一样，但是其中的元素内存地址又是一致的
# 可变数据类型的意思就是说对一个变量进行操作时，其值是可变的，值的变化并不会引起新建对象，即地址是不会变的，只是地址中的内容变化了或者地址得到了扩充。
# 对可变数据类型的操作不能是直接进行新的赋值操作，比如说a = [1, 2, 3, 4, 5, 6, 7]，这样的操作就不是改变值了，而是新建了一个新的对象

list3=[True,2,['df','ty',45],'tr']
list4=['tr',['df','ty',45],2,True]
print(id(list3[0]),id(list4[-1]))   # 8790904592208 8790904592208   # 序列中元素每一个元素指向一个地址，不可变对象值相同，指向的地址相同，可变的对象，代表不同的地址，不共享内存
print(id(list3[2]),id(list4[-3]))   # 41873856 41867328             

list3[2]=list4[-3]
print(id(list3[0]),id(list4[-1]))   # 8790904592208 8790904592208  
print(id(list3[2]),id(list4[-3]))   # 41867328 41867328              #   可变对象赋值后聚有类似引用特性的性质

list3[2][0]=123
print(list4)    # ['tr', [123, 'ty', 45], 2, '1']

tuple4=(True,2,['df','ty',45],'tr')
tuple5=(True,2,['df','ty',45],'tr')
print(tuple4==tuple5)   #true
print(id(tuple4),id(tuple5)) #39015824 38971568		因为含有不可变对象，所以指针不同

tuple6=(True,2,('df','ty',45),'tr')
tuple7=(True,2,('df','ty',45),'tr')
print(tuple6==tuple7)   #true
print(id(tuple6),id(tuple7)) #40720960 40720960		全是不可变对象，所以指针相同

变量是指针，变量赋值，实际是指针变更 。如上验证，相同值（不含可变类型）的不可变类型，在内存中只会存在一份，不会重复保存

许多帖子说对整数类型和元组没有缓存，这边用Python 3.8.2测出来的结果是缓存了……

数据比较

id 比较的是对象的内存地址是否相等

== 比较的是对象的值是否相等

is 比较的是对象的内存地址和值是否相等

字符串

在Python中 常用的俩种字符串类型 str 和 bytes,通过encode()和decode()进行转换，转换时的默认编码格式为UTF-8。Python中str在内存中已Unicode表示

# str.encode([encoding="UTF-8"][,errors="strict"])
# encoding 可省，编码方式
# errors 可省，异常处理方式  strict 非法字符抛异常  ignore 忽略非法字符  replace 用“？”替代非法字符 xmlcharrefreplace 使用xml字符引用
ver = "野渡无人舟自横"
verByte = ver.encode(encoding='UTF-8', errors="strict")
print(verByte)  # b  '\xe9\x87\x8e\xe6\xb8\xa1\xe6\x97\xa0\xe4\xba\xba\xe8\x88\x9f\xe8\x87\xaa\xe6\xa8\xaa'
verBack = verByte.decode(encoding="UTF-8", errors="strict")
print(verBack)
verGB = ver.encode("GBK")
verGBBack = verGB.decode("GBK")
print(verGB)  # b  '\xd2\xb0\xb6\xc9\xce\xde\xc8\xcb\xd6\xdb\xd7\xd4\xba\xe1'
print(verGBBack)

# 拼接 +
print("sfsf"+"---"+"sfas")	#sfsf---sfas
# str.encode([encoding="UTF-8"][,errors="strict"])
# encoding 可省
# errors 异常处理方式  strict 非法字符抛异常  ignore 忽略非法字符  replace 用“？”替代非法字符 xmlcharrefreplace 使用xml字符引用
ver = "野渡无人舟自横"
verByte = ver.encode(encoding='UTF-8', errors="strict")
verByte1 = ver.encode()
print(verByte, verByte1)  # b  '\xe9\x87\x8e\xe6\xb8\xa1\xe6\x97\xa0\xe4\xba\xba\xe8\x88\x9f\xe8\x87\xaa\xe6\xa8\xaa'
verBack = verByte.decode(encoding="UTF-8", errors="strict")
print(verBack)
verGB = ver.encode("GBK")
verGBBack = verGB.decode("GBK")
print(verGB)  # b  '\xd2\xb0\xb6\xc9\xce\xde\xc8\xcb\xd6\xdb\xd7\xd4\xba\xe1'
print(verGBBack)

print("sfsf" + "---" + "sfas")
str = "野渡无人舟自横。test"
print(len(str))  # 12
print(len(str.encode()))  # 28 UTF-8中文3个字节
print(len(str.encode("gbk")))  # 20 GBK中文俩个字节

# 截取 string[start:end:step] 截取字符串，start:end:step 都可省 ，string表示要处理的字符串
# 分割 str.split(sep,maxsplit) sep表示分隔符，可省，默认为None(包含空格，换行'\n' 制表符 ‘\t’ 等 )；maxsplit表示分割的次数，分割的后的集合元素个数为maxsplit+1,-1或省略，则全部分割
print("渡无_人_舟自_横".split('_', 2))  # ['渡无', '人', '舟自_横']
# 合并 strnew= stringchar.join(iterable) stringchar表示用来合并连接iterable元素的字符，iterable表示可迭代对象，如列表，元组
lst = ["test", "测试", "kcs"]
print("".join(lst))  # test测试kcs
print("@" + "@".join(lst))  # @test@测试@kcs
# 计数 str.count(substr[start[,end]]) substr在str中出现的个数，start和end描述检索范围，可省略
# 首次 str.find(substr[start[,end]]) substr在str中首次出现的索引，不存在为-1。rfind表示从右边开始查找
# 首次索引 str.index(substr[start[,end]]) substr在str中首次出现的索引, 不存在时抛异常。rindex表示从右边开始查找
# 开始 str.startswith(substr[start[,end]]) str检索范围是否以str开头，start和end描述检索范围，可省略
# 结尾 str.endswith(substr[start[,end]]) str检索范围是否以str开头，start和end描述检索范围，可省略
# str.lower()  str.upper() 小大写转换
# 去除特殊字符 str.strip([chars]) 表示去除字符串str左右俩边的字符  lstrip表示去掉左边的，rstrip表示去掉右边的
str = " @ssfa . "
print(str.strip('@.'))  # " @ssfa . "
print(str.strip('@. '))  # "ssfa"   去掉左右俩边的“@"和”.“和空字符
print(str.strip())  # "@ssfa ."   默认去掉左右俩边的空字符和 制表符\t 换行\n 回车符\r等特殊字符等

# 格式化
# 格式化  方式1：  ’%[-][+][0][m][.n]格式化字符‘%exp   说明：  -|+|0 可选参数 分别表示左、右、右对齐，并为无符号数添加符号 m表示占有的宽度 n表示小数点位  exp 要转换的项，多个用元组表示，不能用列表
# 常用 格式化字符 ：   %s 字符串str   %c 单个字符    %d %i 十进制整数  %f %F 浮点数  %r字符串repr %% 字符%   %x 十六进制  %o 八进制  %e %E指数

strMoban = "姓名：%s 年龄:%03d  身高：%02.2f 米 "
pinfo = ('kcs', 30, 1.65)
strAll = strMoban % pinfo
print(strAll)  # 姓名：kcs 年龄:030  身高：1.65 米

# 方式2 使用format 推荐方式   str.format(args)  str:模板  args 要转换并替换占位的字符，多个用,隔开 模板定义  {[index][:[[fill]align][sign][#][
# width][.precision][type]]} index 表示占位符在参数列表的起始位置，默认0 ，  fill表示空白处填充字符 align 对齐方式用< > = ^分别表示左 右 右 居中对齐
#  sign 用于给无符号数添加符号 用 + - 空格 表示  # 表示是否给数据加上进制标识 width占用宽度 precision 小数位 type 指定类型   S：字符串 D:十进制数  C:将十进制自动转换为Unicode字符
# b:将十进制转换为2进制 o:十转八  x X:十转十六  f F 浮点数   %显示百分比   e E 转为科学计数  g G:自动在e f ,E F中切换


strMb = "姓名:{:-<9s} 年龄：{:0<+#3d} 身高:{:0< 3.2f}米 鞋码：{:0<o} newage:{:0>b}"
strRet = strMb.format(" k c s", 30, 1.65, 39, 30)
print(strRet, "test")   #   姓名: k c s--- 年龄：+30 身高: 1.65米 鞋码：47 newage:11110 test

strMb = "姓名:{0:-<9s} 年龄：{2:0<+#3d} 身高:{1:0< 3.2f}米 鞋码：{3:0<o} newage:{4:0>b}"
strRet = strMb.format(" k c s",1.65, 30,  39, 30)
print(strRet, "test")   #   姓名: k c s--- 年龄：+30 身高: 1.65米 鞋码：47 newage:11110 test

正则表达式

规则和C#几乎一致 用r R替代@取消\转义

. \w \s \d \b ^ $

? + * {n} {n,} {n,m}

​ 模块名re ,需引入 import re

re.match(pattern,string[,flags])

​ re.match(pattern,string[,flag]) 返回match 对象： flag : A或ASCII 只进行ASCII匹配 ; I 或 IGNORECASE 忽略大小写 ； M或MUTILINE ; S 或 DOTAIL 表示.匹配任意字符，包含换行符 ； X或VERBOSE 忽略模式字符字符串中未转义的空格和注释

re.search(pattern,string[,flags])

re.findall(pattern,string[,flags])

re.sub(pattern,repl,string,count,flags)

re.split(pattern,string,[maxsplit],[flags])

​

!和C#不同是从头开始匹配，如果开头不匹配，则直接返回none，没有迭代过程

import re

strDemo = "阿sdf_sflweSDF344#SFasfasf%sf7e"
strPt = r"_sf\w+?#"
strPts=r"\w+?_sf\w+?#"
matchRet = re.match(strPt, strDemo, re.I)
matchRet1 = re.match(strPts, strDemo, re.I)  #从头匹配的第一个
print(matchRet,matchRet1)     #  None  !和C#不同是从头开始匹配，如果开头不匹配，则直接返回none，没有迭代过程  <re.Match object; span=(0, 18), match='阿sdf_sflweSDF344#'>
print("起始位置:{:d} 结束位置：{:d} 匹配位置的元组：{:s} 源字符：{:s} 匹配数据：{:s}".format(matchRet1.start(),matchRet1.end(),str(matchRet1.span()),matchRet1.string,matchRet1.group()))
# 起始位置:0 结束位置：18 匹配位置的元组：(0, 18) 源字符：阿sdf_sflweSDF344#SF 匹配数据：阿思sdf_sflweSDF344#
ret=re.search(strPt,strDemo,re.I)  #匹配的第一个
print("起始位置:{:d} 结束位置：{:d} 匹配位置的元组：{:s} 源字符：{:s} 匹配数据：{:s}".format(ret.start(),ret.end(),str(ret.span()),ret.string,ret.group()))
# 起始位置:5 结束位置：18 匹配位置的元组：(5, 18) 源字符：阿sdf_sflweSDF344#SF 匹配数据：_sflweSDF344#
strPt = r"sf"
allRet=re.findall(strPt,strDemo,re.I)  #查找全部匹配的字符串，并以列表返回
print(allRet)   # ['sf', 'SF']
strRp=re.sub(strPt,'1111',strDemo,1,re.I)   #阿sdf_1111lweSDF344#SFasfasf%sf7e  1表示只替换一次
print(strRp)    # 阿sdf_1111lweSDF344#SF
strSplit=re.split(strPt,strDemo,2,re.I)     #['阿sdf_', 'lweSDF344#', 'asfasf%sf7e']  2表示分割俩次
print(strSplit)

函数

​ # def 定义,注意冒号: 多个参数用, 当传递的实参是不可变对象时，进行值传递，为可变对象时，进行引用传递

def functionname([pramlst]) :	  #命名规范：全小写

​ [’’‘comment’’’] # 和C#的///给函数添加注释类似

​ [funcbody] # 函数体，如果有返回值，则用return

​

​ def functionDemo(name,age)

​ print(“姓名：{😒} 年龄：{：d}”.format(name,age))

def function_demo(name, age, des="说明"):     # 有默认值，可以不传
    print("姓名：{:s} 年龄：{:d} des:{:s}".format(name, age + 1, des))    
    
function_demo("kcs", 29, "kingdee")  # 位置参数 传参时，按位置顺序指定   姓名：kcs 年龄：30 des:kingdee  姓名：kcs 年龄：30 des:说明
function_demo(age=29, name="kcs")  # 关键字参数，传参时，按名称传值，无关顺序

def func_demo(*prams):
    print(prams)  # ('tet', 23, 'rt')  *可变参数，会处理放到一个元组中
    for item in prams:
        print(item)
        
func_demo('tet', 23, 'rt')

def func_dicDemo(**params):
    print(params)  # {'tes': 1, 'dte': 'te'}
    for key, value in params.items():
        print(key, value, end='_')

func_dicDemo(tes=1, dte='te')  # ** 表示输入的参数，类似于键值对形式，并会转换成字典

#全局变量，局部变量 定义在函数外，函数内，函数内的局部变量通过 global 修饰后，就成为全局变量

匿名函数

result=lambda[arg1[,arg2…]]:expression

import math
def circlearea(r):
    result=math.pi*r*r
    return  result
r=10
print(circlearea(r))    #314.1592653589793
retlamda=lambda r:math.pi*r*r	#lambda表达式是这样写的
print(retlamda(r))  #314.1592653589793

面向对象

类，方法，属性

​ class ClassName: # 命名规范 驼峰命名

​ ‘’‘类注释信息’’’ # 类说明

​ statement #类主体

​ 创建类实例 cn=ClassName(paramlst)

​ paramlst是参数列表 ，可省

__init__(self) 构造函数，不手动创建时除self是无参的，手动创建必须包含一个self参数，指向实例本身的引用，且必须放在第一个

class ClassDemo:
    name = "kcsdemo"  # 类属性 定义在类中，实例方法之外，用法和C#的静态变量类似  各类实例共用
    age = 60
    address = "shenzhen"
    __pinfo="private 信息"
    _ptinfo="protected 信息"

    def __init__(self):
        self.des='实例属性，由实例定义，也只能由实例访问'

    def instaceFunc(self, str):  # 实例方法 定义在类中 第一参数必须是self
        print("name:{:s} age {:d} address:{:s} other:{:s}".format(ClassDemo.name,ClassDemo.age,ClassDemo.address,str+"——"+ClassDemo.company+":"+self.des))      # 通过类名.类属性访问


ClassDemo.company='kingdee'  # 自由的添加类属性
ins1=ClassDemo()
ins2=ClassDemo()
ins2.des="实例属性自由添加修改"
ins1.instaceFunc('test')   # name:kcsdemo age 60 address:shenzhen other:test——kingdee:实例属性，由实例定义，也只能由实例访问
ins2.instaceFunc('test')   # name:kcsdemo age 60 address:shenzhen other:test——kingdee:实例属性自由添加修改

访问权限

方法 属性的访问权限设置  _name 单下划线加名称 protected  __name 双下滑线加名称表示private   __name__前后双下划线一般是系统内置命名

属性

# 通过@property 将方法转换为属性，调用时，不在需要（）
# @property
# def methodname(self): # 表示类的实例
#     block             # 方法体
class ProClass:
    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.__area=0.00
    @property
    def area(self):     #只读属性 area 可访问，不可修改，返回私有字段的属性为只读属性
        self.__area=self.width * self.height
        return self.__area


rect = ProClass(29, 31.5)
print("面积为：{:.2f}".format(rect.area))  # 面积为：913.50
#rect.area=100 #can't set attribute  只读不可修改

继承

class ClassName(baseclasslist): #baseclasslist 要继承的基类，多个用,隔开，和C#类单继承不一样

​ ‘’‘类注释’’’

​ statement #类体

方法重写

​ 直接在子类中写一个同名，同参数的方法就重写了

调用基类的够着函数

	super().__init__()

模块

一个 .py文件 就是一个模块

每个python模块（python文件，也就是此处的test.py和import_test.py）都包含内置的变量__name__,当运行模块被执行的时候，__name__等于文件名（包含了后缀.py）；如果import到其他模块中，则__name__等于模块名称（不包含后缀.py）。而“main”等于当前执行文件的名称（包含了后缀.py）。进而当模块被直接执行时，name == 'main’结果为真。

导入模块

​ import modulename

​ from modulename import member #member 可以是一个也可以是多个，多个用,隔开，也可用*通配符代表所有member

import  ootest

ootest.ClassDemo().instaceFunc("testModule")
print(ootest.ClassDemo.company)     #模块名.相应对象 会把引入模块执行一次 
if __name__=='__main__':
    print("no module",__name__,'__main__')
else:
    print(__name__,'__main__')

from  funcDemo import *
print(circlearea(20))   # from import 不用再写模块名  全部引入，会把引入模块执行一次 譬如funcDemo中的 func_demo('tet', 23, 'rt') 会执行输出 ('tet', 23, 'rt')

from funcDemo import  circlearea
print(circlearea(30))   # 指引入需要的

import funcDemo
print(funcDemo.circlearea(20))

以下为引入的模块

ootest

class ClassDemo:
    name = "kcsdemo"  # 类属性 定义在类中，实例方法之外，用法和C#的静态变量类似  各类实例共用
    age = 60
    address = "shenzhen"
    __pinfo="private 信息"
    _ptinfo="protected 信息"

    def __init__(self):
        self.des='实例属性，由实例定义，也只能由实例访问'

    def instaceFunc(self, str):  # 实例方法 定义在类中 第一参数必须是self
        print("name:{:s} age {:d} address:{:s} other:{:s}".format(ClassDemo.name,ClassDemo.age,ClassDemo.address,str+"——"+ClassDemo.company+":"+self.des))      # 通过类名.类属性访问


ClassDemo.company='kingdee'  # 自由的添加类属性
ins1=ClassDemo()
ins2=ClassDemo()
ins2.des="实例属性自由添加修改"
ins1.instaceFunc('test')   # name:kcsdemo age 60 address:shenzhen other:test——kingdee:实例属性，由实例定义，也只能由实例访问
ins2.instaceFunc('test')   # name:kcsdemo age 60 address:shenzhen other:test——kingdee:实例属性自由添加修改

# 方法 属性的访问权限设置  _name 单下划线加名称 protected  __name 双下滑线加名称表示private   __name__前后双下划线一般是系统内置命名

funcDemo

def function_demo(name, age, des="说明"):  # 有默认值，可以不传
    print("姓名：{:s} 年龄：{:d} des:{:s}".format(name, age + 1, des))

function_demo("kcs", 29, "kingdee")  # 位置参数 传参时，按位置顺序指定   姓名：kcs 年龄：30 des:kingdee  姓名：kcs 年龄：30 des:说明
function_demo(age=29, name="kcs")  # 关键字参数，传参时，按名称传值，无关顺序


def func_demo(*prams):
    print(prams)  # ('tet', 23, 'rt')  *可变参数，会处理放到一个元组中
    for item in prams:
        print(item)

func_demo('tet', 23, 'rt')

def func_dicDemo(**params):
    print(params)  # {'tes': 1, 'dte': 'te'}
    for key, value in params.items():
        print(key, value, end='_')

#func_dicDemo(tes=1, dte='te')  # ** 表示输入的参数，类似于键值对形式，并会转换成字典

#全局变量，局部变量 定义在函数外，函数内，函数内的局部变量通过global修饰后，就成为全局变量

# 匿名函数
import math
def circlearea(r):
    result=math.pi*r*r
    return  result
r=10
print(circlearea(r))    #314.1592653589793
retlamda=lambda r:math.pi*r*r
print(retlamda(r))  #314.1592653589793

模块检索

​ 模块文件检索优先顺序：

​ 1.在当前目录查找

​ 2.在环境变量 PYTHONPATH下的每个目录进行查找

​ 3.在Python的默认安装目录查找

​ 以上路径都保存在模块sys的属性path中

		import sys
		print(sys.path)
     
   #['E:\\PythonDemo', 'E:\\PythonDemo', 'C:\\Program Files\\JetBrains\\PyCharm 2020.1.2\\plugins\\python\\helpers\\pycharm_display', 'C:\\Program Files\\python38.zip', 'C:\\Program Files\\DLLs', 'C:\\Program Files\\lib', 'C:\\Program Files', 'C:\\Program Files\\lib\\site-packages', 'C:\\Program Files\\JetBrains\\PyCharm 2020.1.2\\plugins\\python\\helpers\\pycharm_matplotlib_backend']

​ 添加检索路径

​ egpath:“E:\program\demo”

​ 1.临时添加(只在执行当前文件的窗口中有效，窗口关闭即失效)

​ sys.path.apend(“E:\program\demo”)

​ 2.在Python的安装目录下的 Lib\site-packages子目录中添加*.ph 文件 将路径添加到其中

​ E:\program\demo

​ 3. 在环境变量 PYTHONPATH添加

​

​

包

包名 小写

# 创建包就是创建一个文件夹，并在改该文件夹下创建一个__init__.py的文件，该文件可为空，也可添加代码，在导入包的时候会自动执行
print("包名：{:s}".format(__name__))

​

输出如下：

​ 包名：pkgdemo1 # 引用包会先执行 __init__.py

​ 宽度： 800
高度： 900

异常处理

try:

​ block1

except [(ExceptionName1,ExceptionName2)[as alias]] :

​ block2 # 发生异常执行 eg:print(alias)

else:

​ block3 # 不发生异常执行

finally:

​ block4 # 始终执行

​

抛出异常

​ raise [ExceptionName[(异常描述信息)]]

文件及目录操作

文件

Python 内置了File对象 通过open()，close() 要及时关闭文件

​ file=open(filename[,mode[,buffering[,encoding]]])

filename:如果与py文件在同一目录下，写文件名就可以，不在同一目录要全路径或相对路径

mode:

​ r 只读模式,

​ rb 只读模式，以二进制打开文件，一般适用于非文本文件，如图片，声音等，

​ r+ 读或覆盖原有内容写 ,

​ rb+ 读或覆盖原有内容写 ,适用非文本文件

​ w 只写模式,

​ wb 二进制，只写模式，适用于非文本文件,

​ w+ 清空原文内容，使其变为空文件，对这个空文件有读写权限，

​ wb+ 读写,

​ a 追加模式，如果文件不存在，则创建新文件，用于写入 ,

​ ab 二进制追加 ,

​ a+ 追加模式，如果文件不存在，则创建新文件，用于读写 ,

​ ab+ 二进制追加模式

filetxt= open(r"C:\Users\Administrator.-20171206IUEUWS\Desktop\pythonNode\Test\tets.txt","r",1,encoding="utf-8")
print(filetxt)
str=filetxt.read()  #测试python file open
print(str)
filetxt.close()

filetxt1= open(r"C:\Users\Administrator.-20171206IUEUWS\Desktop\pythonNode\Test\tetsRW.txt","a+",1,encoding="utf-8")
filetxt1.write("safasf")
filetxt1.close()

filetxt2=open(r"..\testfile\te1.txt")
print(filetxt2)
filetxt2.close()

if os.path.exists(r'..\testfile\te1.txt'):
    os.rename(r'..\testfile\te1.txt', r'..\testfile\test.txt', )  # 删除文件 如果不存在，则异常

print(os.stat(r'..\testfile\test.txt'))	#os.stat_result(st_mode=33060, st_ino=1407374883553465, st_dev=1710438242, st_nlink=1, st_uid=0, st_gid=0, st_size=86, st_atime=1591954640, st_mtime=1592186618, st_ctime=1591954640)
os.startfile(r'..\testfile\test.txt')  # 用默认关联的程序打开文件
print(os.access(r'..\testfile\test.txt', os.W_OK))  # 获取对文件的操作权限  os.R_OK：读取  os.W_OK：写入 os.OK：执行  os.F_OK：存在

import  stat	#引入状态包
os.chmod(r'..\testfile\test.txt',stat.S_IREAD)
print(os.access(r'..\testfile\test.txt', os.W_OK))
# if os.path.exists(r'..\testfile\te1.txt'):
# os.remove(r'..\testfile\test.txt')  #删除文件 如果不存在，则异常

with 和C# using 功能类似，控制自动释放

with expression as target

​ with body

with open(r"..\testfile\te1.txt","r+",1,encoding="utf-8") as filearw:
    str =filearw.read()
    print('111'+str)    #111testa

目录操作

​ os 是内置的与操作系统功能和文件系统相关的模块，不同的系统表现可能表现不同

import  os

print(os.name)      # nt 用于获取操作系统类型 nt：windows  posix:Linux,unix,Mac os
print(os.linesep)   #  当前操作系统的换行符
print(os.sep)       # \ 当前操作系统的操作分隔符
print(os.getcwd())  #  E:\PythonDemo\ostest 获取当前路径
print(os.path.abspath(r'..\testfile\demo1.py')) #  E:\PythonDemo\testfile\demo1.py 获取相对路径的绝对路径
print(os.path.join(os.getcwd(),'test')) # E:\PythonDemo\ostest\test 拼接路径，不需要/
print(os.path.exists(r'..\testfile'))   # True
print(os.path.isdir(r'..\testfile'))    # True
# print(os.listdir('E:\PythonDemo'))
if not os.path.exists('DirDemo'):
    print(os.mkdir('DirDemo',)) # None
if not os.path.exists('E:\PythonDemo\DirTest'):
    print(os.mkdir('E:\PythonDemo\DirTest'))    # None
#  print(os.mkdir(r'E:\PythonDemo\Dirtest\1\2'))   #系统找不到指定的路径。: 'E:\\PythonDemo\\Dirtest\\1\\2'
if not os.path.exists(r'E:\PythonDemo\Dirtest\1\2'):
    print(os.makedirs(r'E:\PythonDemo\Dirtest\1\2'))    # None

os.rmdir(r'E:\PythonDemo\Dirtest\1\2')  # 只能删除空目录

import shutil   #标准模块

shutil.rmtree(r'E:\PythonDemo\ostest\DirDemo')  # 可以删除非空目录

tuples=os.walk(r'E:\PythonDemo')    #遍历目录，返回元组生成器对象
for tp in tuples:
    print(tp)
# ('E:\\PythonDemo', ['.idea', 'DirTest', 'FileDemo', 'ostest', 'pkgdemo1', 'testfile', '__pycache__'], ['demo1.py', 'DicTest.py', 'funcDemo.py', 'moduletest.py', 'modulpath.py', 'ootest.py', 'pdemo1.py', 'pkgtest.py', 'propertyDemo.py', 'retestdemo.py', 'strtest.py', 'TestDemo.py', 'tupletest.py', 'ZetTest.py', '人哇若.py'])
# ('E:\\PythonDemo\\.idea', ['dictionaries', 'inspectionProfiles'], ['.gitignore', 'misc.xml', 'modules.xml', 'PythonDemo.iml', 'workspace.xml'])
# ('E:\\PythonDemo\\.idea\\dictionaries', [], ['Administrator.xml'])
# ...

数据库链接

sqlite:

​ 内置

#1.创建链接对象 connect()  链接参数以具体模块定义为准      相当于sqlConnection
#2.游标对象 cursor() 用于指示抓取数据操作的上下文，用于执行sql ,proc等      #相当于sqlCommand+sqlAdapter

import  sqlite3
conn=sqlite3.connect('iteTest.db')
cursor=conn.cursor()
cursor.execute('drop table User')
cursor.execute('create table User(id int(10) primary key,name nvarchar(10),age int(3))')
cursor.close()
conn.commit()
conn.close()

mssql:

​ 需要先安装包,在终端 pip install pymssql；因为网络等原因，通常需要离线下载后，在本地安装，如：

pip install E:\PythonDemo\pymssql-2.1.4-cp38-cp38-win_amd64.whl

import pymssql

try:
    msConn = pymssql.connect('127.0.0.1', 'sa', 'kangzi20119', 'ReportServer')
    if msConn:
        print("链接成功")
        cursor = msConn.cursor()
        cursor.execute("SELECT * FROM Roles")  # 执行查询
        data = cursor.fetchall()
        print(type(data))
        print(data)
        msConn.close()
except Exception as ei:
    print("链接失败：" + str(ei))

常用内置函数

​ testfield=125

type(testfield) 返回变量的类型

id(testfield) 返回变量所指的内存地址

str(testfield) 将数值转换为字符串

range(start,end,step):返回一系列连续的整数 range(7) 返回 0~6

(‘E:\PythonDemo\.idea\dictionaries’, [], [‘Administrator.xml’])

…

## 数据库链接

sqlite:

​	内置

```python
#1.创建链接对象 connect()  链接参数以具体模块定义为准      相当于sqlConnection
#2.游标对象 cursor() 用于指示抓取数据操作的上下文，用于执行sql ,proc等      #相当于sqlCommand+sqlAdapter

import  sqlite3
conn=sqlite3.connect('iteTest.db')
cursor=conn.cursor()
cursor.execute('drop table User')
cursor.execute('create table User(id int(10) primary key,name nvarchar(10),age int(3))')
cursor.close()
conn.commit()
conn.close()

mssql:

​ 需要先安装包,在终端 pip install pymssql；因为网络等原因，通常需要离线下载后，在本地安装，如：

pip install E:\PythonDemo\pymssql-2.1.4-cp38-cp38-win_amd64.whl

import pymssql

try:
    msConn = pymssql.connect('127.0.0.1', 'sa', 'kangzi20119', 'ReportServer')
    if msConn:
        print("链接成功")
        cursor = msConn.cursor()
        cursor.execute("SELECT * FROM Roles")  # 执行查询
        data = cursor.fetchall()
        print(type(data))
        print(data)
        msConn.close()
except Exception as ei:
    print("链接失败：" + str(ei))

常用内置函数

​ testfield=125

type(testfield) 返回变量的类型

id(testfield) 返回变量所指的内存地址

str(testfield) 将数值转换为字符串

range(start,end,step):返回一系列连续的整数 range(7) 返回 0~6