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 类似）

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

​ 不可变性（和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中 常用的俩种字符串类型 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()

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

常用内置函数

​ testfield=125

type(testfield) 返回变量的类型

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

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

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