（待优化）python入门

前言

假期自学，代码都是自己看视频时联想敲得，与任何教程无关。为了腾电脑的地方，顺便复习下，学习后边的内容，就整理了下之前敲得。注释与解释不太多（别幻想别人写一大堆注释，有写注释的习惯吗），看的话凑活看，不懂得可以联系me。其他内容持续更新。

python版本:3.6.6

python在线运行代码：->>>> [菜鸟在线 Editor](菜鸟教程在线编辑器 (runoob.com))->>>>

基本输入输出

输入 input(string)。string 为提示的语句。

输出 print(value)。括号内可以是任意变量名，或者值。

功能很多，后边还有。

1. if…elif…else

if条件中且用‘and’ 或用‘or’
keyword: “产生随机字符串”，

 ##  if条件中 且 用‘and’ 或 用‘or’n = input("输入任意数字")
if int(n) % 2 == 0 and n != "0":print("输入为偶数")
elif int(n) % 2 != 0:print("输入为奇数")
else:print("输入非数字或 “0” ")

2. 运算符、文件写入、id()

2.1运算符

2.1.1 算数与赋值运算符

几个与其他语言不同，或比较特殊的几个。

** ：幂，如2**5为2⁵ 。

// ：取整除，“/”，所得结果带小数部分。“//”，结果只有整数部分。

/=、//=、**=：类比理解。

2.1.2 逻辑运算符

在条件组合时不是其他语言那样 “||”, “&&”, “!”。

“||” 用 “or” 替换
“&&” 用 “and” 替换
“!” 用 “not” 替换

2.1.3 位运算符

& ^与， | ^或， ^ ^异或， ~ ^取反， << ^左移， >> ^右移。运算只针对于二进制数，运算逻辑与其他语言相同。

其中用到格式化输出字符串。可通过目录前往了解学习。

#  encoding:utf-8
#  keyword:“input”，“逻辑运算符”，“>>”，“<<”，“|”，“^”,
#      “变量地址”
from os import errora = input("输入字符串")
x = input("输入一个数 X:")# 输入x
try:x = int(x)
except:print("输入数据有误!")exit(0)
# 输入y
y = input("输入一个数Y:")
try:y = int(y)
except:print("输入数据有误!")exit(0)templea = "% 8s\n% 10d\n"
templeb = "{0: >9s}\n{1: >#20b}\n"
templec = "{0: >9s}\n{1: >#20b}\n{2: >#20b}\n"a += "\n"
prs1 = [("原数(x):", x),("原数(y):", y),("值id(x)：", id(x)),
]
prs2 = [("二进制(x):", x),("二进制(y):", y),("右，移(x>>2):", x >> 2),("左，移(x<<2):", x << 2),
]
prs3 = [("异或(x^y,y^x):", x ^ y, y ^ x),("_或(x|y，y|x):", x | y, y | x),
]
for item in prs1:a += templea % item
for item in prs2:a += templeb.format(item[0], item[1])
for item in prs3:a += templec.format(item[0], item[1], item[2])

3. while

与其他语言没大区别，就是没括号

string = "A"
#  根据字符取ascll码值
a = ord("A")
i = 0
while i < 60:#  根据ascll码值取字符st ring += chr(a)if i % 3 == 0:print()print(a, ":" + chr(a), end=" ")i = i + 1a = a + 1
print(string)

4. 序列

连续内存空间数据存储，每个项都有唯一值（成为索引或位置）指向。

序列结构有：

列表 [ list,list,list ]。
元组 (tuple, tuple, tuple)。
字典 { dictionary, dictionary, dictionary }。
字符串 string

定义时：序列为 [ ] ,元组为 ( ) ,字典为 { } 。每项都可以是其他数据结构，即各项之间没有必要的限制条件。

4.1 列表

通过确定值初始化。

listname =[ value1,value2 ,value3 ,value4 ,value5 ,value6]

通过表达式初始化。

生成指定范围列表。

使用range函数控制生成元素数量，listname =[expression for var in range]
- expression 。当前生成元素var进行的运算。
  
  do0 或
  
  do1 if case1 else if do2 else do3
- var 。当前生成元素的变量名。
- range 。 range函数指定生成数量。
```
listname=[i+0.1 for i in range(20)]
```

根据列表生成列表。

就是在 1 的基础上用一个列表替换了range函数。

listname=[i for i in range(10)] #先 生成一个列表
newList=[ i%5+1 for i in listname]# 根据那个生成这个。全部变为1~5

添加筛选条件。

listname=[i for i in range(20)] #再 生成一个列表
newList=[ i if i%2==0 else i*10 for i in list if i <10]
# 根据那个 添加筛选条件并生成新的。首先判断是否小于10，然后再看前边的条件怎么进行运算。

以上几种操作，等同于

list=[]
for item in list:if  item... :#执行操作elif item... :#执行操作else:#执行操作

4.1.1 列表的基本操作

索引（Indexing）。列表可通过索引取值，与其他编程语言数组操作一样。
- listname.index ( value )。返回指定值第一次出现的索引值。
  
  指定值不存在会报错，所以建议结合 in 操作。（在4.1.2）

序列支持负数索引, 当索引值为负时从右向左数

切片（Slicing）。取出整个序列的连续一部分。

list ( start , end,step)

name = ["张三", "张四", "张五", "李四", "李五"]
number = [1, 2, 3, 4]namenum = name + numberprint("namenum[1:5:2]", namenum[1:5:2], "")
# 切片[ 从第 2 个开始，到第 6 个以前，间隔为 2 ]
print("namenum[:5:]", namenum[:5:], "")

加（Adding）。两个序列所有元素直接相加。

乘（Multiplying）。序列乘一个整数，产生一个同样的序列重复整数次的新序列。

print("")
name=["张三","张四","张五","李四","李五"]
number=[1,2,3,4]
#  乘
print(name*3)
#  加
print("name+number", name+number,"")
#  切片【从第二个开始，到第六个以前，间隔为2】
namenum=name+number
print("namenum[1:5:2]",namenum[1:5:2],"")
print("namenum[:5:]",namenum[:5:],"")

4.1.2 列表的常见方法

len。返回列表的长度。len ( list )。
max。输出列表中的最大值。

只支持元素全部为数字类型的列表。max ( list )
min。用法同max。
in。返回 bool 值。value in list。

只能判断一层，如果子元素为列表或者元组之类的结构，则不会判断其内部值。
not in 。同上。

numbers=[1.2,123.1,456,486,456,156,111,222,333]
print(numbers)
print("最大值",max(numbers))
print("最小值",min(numbers))
print("长度",len(numbers))
x=456
print("是否存在",x,x in numbers)
y=678
print("是否不存在",y,y not in numbers)

4.1.3 列表的遍历

for item in list。依次把list的值赋值给item，然后进行其他操作。对原列表无影响。
for index, item in enumerate ( list )。

index为索引值，item为索引值对应的项。

name = ["dage", "erge", "sange", "laosi", "laowu", "xiaoliu"]
print(name)
a=0
for linshide in name:if a % 2==0 :## 换行print("\n")print("\t"+linshide,end="")## 不换行打印a=a+1 ## python不支持自增|自减运算
for xuhao, name in enumerate(name):if xuhao % 2==0 :print("")print("\t序号是：" + str(xuhao), "\t名字是" + name, end="")##不换行输出

4.1.4 列表的增删改

增，apend（）。
删。
- del listname[ index ]。直接删除index索引值对应的值，后续元素前移。
- listname.remove( “value” )
  
  删除不存在的值会报错。所以可结合 in 操作使用。
- listname.pop()。删除并返回最后一个元素。
  
  通过与append结合使用，可以模拟栈结构。后进先出

改。 listname [ index ] = value

name = ["dage", "erge", "sange", "laosi", "laowu", "xiaoliu"]
print("\n定义的数组为：")
print(name)#  添加:
name.append("laomo")
print("\n添加一个后的数组：" )
print(name)#  通过索引获取指定值。直接重新赋值。
strint=name[0]="dageda"
print("\n添加一个后再修改下的数组：")
print(name)# 删除指定“dage” 即 删除name[2]
del name[0]
print("\n删除 name[0] 的数组：")
print(name)

4.1.5 列表的统计求和

统计。返回指定值在列表中出现的次数。list.count(value)

不存在时返回 0，所以不用判断是否存在。

求和。统计各项的和。可指定统计开始的位置。sum( listname [ index ] ) 或sum( listname )

仅限元素全为数字格式时。

nums=[123,456,654,123,987,147,258,654,852,147,741,852]
nums_plus=nums*2# 统计某一元素出现次数
if 147 in nums_plus :print("147出现次数为\t:"+ str(nums_plus.count(147)))
else:print(str(147)+"不存在")print("nums和:"+str(sum(nums))+"\nnums_plus和为\t:"+str(sum(nums_plus)))

str ( value ) ：强行转换为字符串。print操作必须全部为字符串，如果不转换，则会提示数字无法与字符串相加。

4.1.6 列表的排序

sort。在原列表上排序。listname.sort() 或 listname.sort( key=None ,reserve=False)

后者括号中的两项都可以省略。

第一项为指定排序时是否忽略大小写。key=None 或key=str.functionName 这项的意思是，指定排序时每个列表元素进行的转换。

第二项为指定排序是否为逆序的。

sorted。返回已排序的列表。sort(listname) 或 sorted ( listname , key = None ,reserve = False )

规则同上。

# 定义一种排序 key
def sortkey(nu):return nu%10# 定义俩序列
names=["toms","Jone","Tony","alice","obma"]
numbers=[123,456,852,147,369,741,963]print("\n原序列names:")
print(names)
print("\n原序列numbers:")
print(numbers)#排序
#临时列表，保留原列表
term1=names
term2=numbersterm1.sort()
term2.sort()
print("\n升序排列names(区分大小写)：")
print(term1)#添加key
term1=names
term1.sort(key=str.lower) # str.lower 字符串全部转换为小写的方法。
print("\n升序排列names(不区分大小写)：")
print(term1)print("\n升序排列numbers：")
term2=numbers
print(term2)# 原列表
term2.sort(key=sortKey)# 按照开头定义的key排序
print(term2)# 排序后print("\n降序排列numbers：")
term1=numbers
term2= sorted(term1,key=sortKey,reverse=True)
print(term2)

4.2 元组

元组不能对元素赋值，即修改，不能删除一个或多个元素，只能整个删除。若要修改，可以整个元组重新赋值。
元组可进行组合，直接进行 + ，*。
列表的基本操作与常用方法元组也可使用。

序列为’[]’,元组为’()’,字典为’{}’。

# encoding:utf-8
empty=()
num = 156
st = "string_a"
one_index = [12, 45, 65, 78]tup1 = ("123456321",)##? 声明一个很复杂的元组
tup2 = ( num, st, one_index)print("有一个元组为:",tup2)tup3 = ("ab", "cd", "ef", 98765132, "#$%$&")alltuple = tup1 + tup2 + tup3
print("组合后的元组：",alltuple )##? 输出指定序号元素
t = input("请输入元组序数" + "1~" + str(len(alltuple)))
print(alltuple[int(t) - 1]) # 序号从 0 开始

4.3 字典

类似于我们使用的字典，一个关键字，然后对应一些内容。查找时根据关键字查找。

4.3.1 字典的生成

序列为’[]’,元组为’()’,字典为’{}’。

直接赋值。 dicti_b = {"拉丁语": "Latin", "鸟语": "!&*/"}

dict 生成。

这里有个坑。如果组合的两部分不是元组或者列表，则合成的字典回事乱序的，且是随机组合的。即，用圆括号，或者方括号，别用花括号。

English = ["Chinese", "English", "Japanese", "Russian", "French", "German", "Korean"]
Chinese = ["中文", "英语", "日语", "俄语", "法语", "德语", "韩语"]didi = zip(Chinese, English)
dicti= dict(didi)

# 输出 clear 后的字典 d 中的元素及个数
print("dicti_c clear()后" + "dicti_c还有" + str(len(dicti_c)) + "个元素")
print(dicti_c)# del用于删除对象
del dicti_d
print("delete后的 e")

4.3.2 字典基本操作

先生成一个字典。

name = ("吴晓咖","刘佳怡","徐之才","单久思","曹侃儿","开俊峰","倪吉本","苗人凤","荣家达","狄俊娥","牛春波","莫桑石",)
sign = ("子鼠", "丑牛", "寅虎", "卯兔", "辰龙", "巳蛇", "午马", "未羊", "申猴", "酉鸡", "戌狗", "亥猪")
# 生成。
roster = dict( zip(name, sign))
print(roster)

取值。直接用 key 获取。或者使用 get() 方法。

如果key不存在，则会报错。所以可结合 in 操作。或者get()方法。

get()方法获取的key不存在时会返回none。
```
print(roster["徐之才"])
print(roster.get("徐才"))
```
添加。通过赋值的形式。roster[key_name] = key_value
删除。使用 del 操作。del roster[ “徐之才” ]
清除。 clear() 。清除字典里的所有项。dictionaryName.clear()。

遍历。

# 遍历输出值
for xxoo in roster.items():print(xxoo)
# 只输出值，不输出标签的遍历。
for ooxx in roster.keys():print(ooxx)
# 值与标签双遍历。
for key, value in roster.items():print("键是：" + key + "值为：" + value)

4.4 字符串

定义两个字符串

poem_first = "老夫聊发少年狂，左牵黄，右擎苍，锦帽貂裘，千骑卷平冈。为报倾城随太守，亲射虎，看孙郎。"
poem_second = "酒酣胸胆尚开张。鬓微霜，又何妨！持节云中，何日遣冯唐？会挽雕弓如满月，西北望，射天狼。"
letter = "  \n  Transportation has been greatly changed in the past few years. In ancient days, people used to travel by horse or carriage. \n    \t"

4.4.0 字符串读取

切片操作。
完全读取，当个变量。

4.4.1 字符串基本操作

计算字符串长度。len(str)
拼接。使用+操作。str1+str2
```
str_s = poem_first + poem_second
```
去除。
- 截取。string [start : end : step]
```
print("分片字符串为:", poem_first[0:21:4]) # 0~20，每4个字符截断一次。
```
  end 为最后一个字符的后一个索引。即表示到哪个字符之前。
  
  step 为截断字符串的长度。
- 替换。strip()、lstrip()、rstrip()、upper()、lower()、replace()
  
  str.strip([chars])—— 去除字符串左右侧的空格和特殊字符。
  
  str.lstrip([chars])—— 去掉左侧空格和特殊字符。
  
  str.rstrip([chars])—— 去掉右侧空格和特殊字符。
  
  str.upper() —— 全部变大写
  
  str.lower()—— 全部变小写
  
  str.replace(oldchar,newchar) —— 用 newchar 替换 oldchar，返回替换后的字符串。
```
# 去除两侧空格或特殊字符
print("\n英语作文去空格:\t", letter.strip(" "))
# 去除左侧空格或特殊字符
print("\n英语作文去空格:\t", letter.lstrip(" "))
letter.replace("@","t")
```
  str：要操作的字符串，chars可选：要去掉的字符或者字符串，默认去掉换行、空格、回车、制表符。
  
  后两个方法，一个去除左侧的，一个去除右侧的。
转换。
- 分割。split(sep, maxsplit)
```
strs = poem_first.split("。", -1)
print("整首诗按句号分割为：")
for linshi in strs:print("@" + linshi)
```
  sep : 分割的字符或字符串，默认为空格换行符之类的。
  
  需要注意，sep在分割后狙消失了。
  
  maxsplit：分割的次数。默认为能割几次割几次。-1 效果一样。
  
  需要注意，maxsplit为分割次数，产生maxsplit +1项

#  以 GBK 编码格式输出字符串长度
print("\nGBK计数长度为：" + str(len(poem_first.encode("gbk"))))#  以 UTF-8 编码格式输出字符串长度
print("\nUTF-8计数长度为：" + str(len(poem_first.encode())))

4.4.2 字符串检索&索引

定义字符串

mulanshi = "唧唧复唧唧，木兰当户织。不闻机杼声，唯闻女叹息。问女何所思，问女何所忆。女亦无所思，女亦无所忆。昨夜见军帖，可汗大点兵，军书十二卷，卷卷有爷名。阿爷无大儿，木兰无长兄，愿为市鞍马，从此替爷征。东市买骏马，西市买鞍鞯，南市买辔头，北市买长鞭。旦辞爷娘去，暮宿黄河边，不闻爷娘唤女声，但闻黄河流水鸣溅溅。旦辞黄河去，暮至黑山头，不闻爷娘唤女声，但闻燕山胡骑鸣啾啾。万里赴戎机，关山度若飞。朔气传金柝，寒光照铁衣。将军百战死，壮士十年归。归来见天子，天子坐明堂。策勋十二转，赏赐百千强。可汗问所欲，木兰不用尚书郎，愿驰千里足，送儿还故乡。爷娘闻女来，出郭相扶将；阿姊闻妹来，当户理红妆；小弟闻姊来，磨刀霍霍向猪羊。开我东阁门，坐我西阁床，脱我战时袍，著我旧时裳。当窗理云鬓，对镜帖花黄。出门看火伴，火伴皆惊忙：同行十二年，不知木兰是女郎。雄兔脚扑朔，雌兔眼迷离；双兔傍地走，安能辨我是雄雌？"
# 目标字符串
mulan = "木兰"
# 操作字符串

存在？

in 或 not in 可结合切片操作。

#  检测某一字符创是否存在于目标字符串（可以加入切片操作）
print(mulan in mulanshi[0:5:])
print(mulan in mulanshi[0:10:])
print(mulan not in mulanshi)

查找

find、rfind、index、count、startswith、endswith

#  find()   输出指定 “木兰” 在 “木兰诗” 中第一次出现的索引。
print(mulanshi.find(mulan, 7, 390))
#  rfind()  输出指定 “木兰” 在 “木兰诗” 中最后一次出现的索引。
print(mulanshi.rfind(mulan))
#  index()  输出“女”第一次出现的位置。
print(mulanshi.index("女"))
#  count()  输出“木兰”出现次数。
print(mulanshi.count("木兰")
#  判断是否以指定字符串结尾或者开始。同样可加入切片。
print("startswith:唧唧复唧唧",mulanshi.startswith("唧唧复唧唧", 0, 20))
print("startswith:雄雌？",mulanshi.endswith("雄雌？"))

rfind () 为从右开始查找。即返回最后一次出现的索引值。

所有的索引都是从 0 开始。

4.4.3 格式化字符串

4.4.3.1 % 格式

% [ - ] [ + ] [ 0 ] [ m ] [ .n ] typecode

符号	作用
-	左对齐，负数加符号，正数不变
+	右对齐，与上一个比，正数加正号。
0	右对齐，正不加。负加负号，0填充空白，一般与m同用
m	填充后的宽度。
.n	小数点后精度

typecode	含义
%r	字符串 (repr()显示)
%g	指数(e)或浮点数 (根据显示长度)
%s	字符串(str()显示)
%G	指数(E)或浮点数 (根据显示长度)
%c	单个字符输出
% b 、o、d（i）、x	二、八、十、十六进制整数
% e（E）	指数(基底写为e(E))
% f (F)	浮点数,与上相同
%%	字符"%"

4.4.3.2 %代码

template_a = "%s \n市值:%07d 亿元\n网站：https://www.%s.com\n老总:%s\n"
temps = [( "百度",3873, "baidu", "李彦宏"),("阿里巴巴",24500,  "alibaba", "马云"),("腾讯",44200,  "tencent", "马化腾"),
]
for ls in temps:print(template_a % ls)

如代码所示，先声明一个模板，然后再套用。

制作模板。用以上的符号加其他字符串组成。

套用。模板 % 目标字符串即可。

提醒，这种方式为最早的方案，目前官方主推下边的format方式。

4.4.3.3 format 格式

{ [ index ] [ [ : [ fill ] align ] [ sign ] [ # ] [ width ] [ .precision ] [ type ] ] }

位置符号	作用
index	默认按顺序自动分配。可选参数，指定索引位置，从0开始。
fill	可选参数，空白处填充的字符。
align	可选参数，用于指定对齐方式。
<	左对齐。
>	右对齐。
^	居中对齐。需指定宽度。
=	右对齐。只对数字类型有用，尤其用于输出负数。
sign	可选参数，用于指定有无符号数 ’+’：正数添加‘+’号,负数添加‘-’号。 ’-’：只有负号添加符号。 ’ ':正数加空格补齐，负数加负号
#	可选参数，加#时输出二、八、十六进制会添加 0b 0o 0x 前缀

type	…
type	含义
s	对字符串格式格式化
b	十进制数转换为二进制再格式化；
d	十进制数
o	十进制数转换为八进制再格式化；
c	十进制数转换为对应Unicode字符
%	显示百分比(默认小数后六位)
x,X	十进制数转换为十六进制再格式化
e,E	转换为科学计数法再格式化
f,F	转换为浮点数再格式化(默认六位小数)
g,G	e与f或E与F之间互换

4.4.3.4 代码

strin1 = "\n马云,\t身价:\t{0:,.2f}".format(13.4567)
strin2 = "\n刘强东,\t身价:\t{0:.3f}\n".format(21.5153)
strin3 = """\nπ为：{:.3f}\n'101'二进制：{:#b}\n'101'八进制：{:#o}\n'101'十六进制：{:#x}\n""".format(3.14159, 101,101,101 )
strin4 = """\nabc：{abc}\nbcd：{bcd:#x}\ncde：{cde:}\n""".format(abc="11211", bcd=121, cde=[123, 456, 789])
print(strin1,strin2,strin3,strin4)

如上所示，使用方法为字符串后加 “.” 然后 format（）嵌入数值。有演示的两种方法：

按照顺序，依次列出。

指定名称，然后根据名称依次赋值。

5. 正则表达式

基础正则了解：[点我](正则语法整理 | X-Y-Z`s Blog (gitee.io))

5.1 匹配

match

import re
elements = ["15946295618","78945631245","48651534582@qq.com","12348621@163.com" ,"15648934529@gmail.com","萨博隔热垫石膏板","调查表身高多少",
]
regular_express_a = [r"[0-9]{0,12}@(qq|gmail|163)\.com",r"1[0-9]{10}",r"[^0-9a-zA-Z]",
]
for i in elements:for index, j in enumerate(regular_express_a):ret_a = re.match(j, i)if ret_a != None:if index == 0:print("邮箱:", i)breakelif index == 1:print("手机号:", i)breakelif index == 2:print("其他的合规字符串:", i)breakelse:pass

完全匹配字符串。不考虑换行，即使设置为自动换行也按一行匹配。

import re
strs="i have a 98k. other all name it ojbk-.i haven't named it ojbk+.and it have a brother awm.it is a good gun."
regular_express_b = r"(awm|ojbk)[-|+]"
result = re.search(regular_express_b, strs)
if result!=None:print(result)print(result.start(),result.end(),result.group(),result.groups())

返回一个类，详细内容，可取官网查看。

官方文档：正则表达式操作：

findall

import re
strs="i have a 98k. other all name it ojbk-.i haven't named it ojbk+.and it have a brother awm.it is a good gun."
regular_express_b = r"(awm|ojbk)[-|+]"
result = re.findall(regular_express_b, strs)
if result!=None:print(result)

返回所有匹配到的结果，以列表形式。

5.2 替换

re.sub(pattern,string)

import re
string = "蒹葭苍苍，白露为霜。所谓伊人，在水一方。溯洄从之，道阻且长。溯游从之，宛在水中央。\n蒹葭萋萋，白露未晞。所谓伊人，在水之湄。溯洄从之，道阻且跻。溯游从之，宛在水中坻。\n蒹葭采采，白露未已。所谓伊人，在水之涘。溯洄从之，道阻且右。溯游从之，宛在水中沚。\n"
letters = "     Transportation has been greatly changed in the past few years. In ancient days, people used to travel by horse or carriage. The journey was often tiring and tedious. Then people had buses, trains and ships, which could shorten the time of the long-distance trip."
regular_express = [r"(蒹葭|伊人)", r"(en|in|an)"]print(re.sub(regular_express[0], "xx", string))
print(re.sub(regular_express[1], " --XXXn-- ", letters))

5.3 分割

re.split(pattern,string)

import re
names = "焦英武、杨清双、吕纪领、张建春、焦灵卫、赵现伟\n陈秀荣、郎波、程磊、刘子祥、谢绍明 胡红军、张克龙、戴怀海 戴怀敏、张国勤\n李小璇、李军耐、张文博、赵联、肖鹏、边宪武、李伟、李宇、夏廷堂、韩世民、董燕平、张正银\n魏国琼、肖桂茂、李德安、白建永、张旭贵、李香明\n霍建辉、吴旭峰、陈云祥、丁连奇、王遂现、范小锋\n杨宗兵、向书章、李金民、戴家元、刘传禄、贺炳强、云秀芳\n刘善刚、姚海军、贾天义、李加有、方承、杨涛\n杨天海、王富军、张中华、王成林、秦振贵、尚鲜军、李友强、尚加聪"
pattern = r"( |、|\n)"tup = re.split(pattern, names)
for index, item in enumerate(tup):if index % 2 == 0:print("第", int(index / 2), "项：", item)

参考

官方文档：正则表达式操作：

6. 函数

6.1普通函数

函数第一行为描述，在多数IDE中进行函数引用时，可显示。

def reckon(x,y):"""求长方形面积 x: 长，y: 宽."""print("""{str1:{space}>7s}={length:>5d} \n{str2:{space}>7s}={width:>5d} \n{str3:{space}>7s}={squr:>5d} \n""".format(str1="此长方形长",str2="此长方形宽",str3="此正方形面积",length=x,width=y,squr=x * y,space=chr(12288),))reckon(int(input("请输入长")) ,int(input("请输入宽")))

6.2 函数默认值

当函数中出现有默认值时必须位于参数集的最后

def R_S(R, pai=3.14, string=""):"""圆求面积"""print("\n\n", string, "\n", "此圆的半径 r={radius: 5d}\n此圆的面积 S= {squr:.3f}".format(radius=R, squr=R * R * pai ))x = int(input("输入圆的半径"))
R_S(x, string="R_S(x):")
R_S(x, 3, "R_S(x, 3):")
R_S(string="R_S(pai=3.142, R=x):", pai=3.142, R=x)

6.3 匿名函数

临时函数，

#  匿名函数 用 lambda 修饰词前缀.
y = lambda ds: ds * ds * 3.14
print("\n" + str(y(x)))

匿名函数多参

#  传入数组，或多参数。
def func(*par):for i in par:print(i)#  参数原理为：定义一个变量的列表，用*来传入列表地址strs = ["语文", "数学", "英语", "物理", "化学"]
strss = ["Chinese", [12.0, 45.12, 44.11], 45699, bin(423),hex(423)]
func(*strs)
print("\n")
func(*strss)

7. python数据存储原理

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

以上为官方关于 id () 函数的解释。一般来说，在其他语言中，变量名地址生命周期内唯一确定不变，对应地址存储的数值可变。但 python 却是变量的值决定地址。

x="x"
print(id("x"))
print(id(x))

以上代码将会输出同样的值。主要是因为 python 中对对象这一概念的执著。他把每一个数值也视为对象。当你声明一个变量并赋值时，首先python编译器做的是申请内存存储赋的值，然后把这一变量指向这一内存。所以不同的值对应不同的地址。

当赋的值为简单数据类型时，python不会再申请，而是先查找是否申请过，如果申请过，则直接指向这块内存。否则再申请。
复杂数据类型，则不进行检查。因为怕你一个数组存了全个国家的名字，然后接下来几个变量又来赋值，如果检查，那CPU不是要抽两口烟了。

参考：

python id()函数和内存分配理解
Python id() 函数

8. class

#  keyword：“class”，“从序列中取随机元素”，“从字典中取随机元素”
#           “choice”，# encoding:utf-8brand = {"上汽集团": "大众", "东风": "雪铁龙", "奔驰": "Mercedes-Benz", "凯迪拉克": "Cadillac"}
produce_country = ["China", "American", "India", "European"]
code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
# -----------------class---------------->#
class Car:""" 汽车模型 先生成后赋值 """Name = ""Brand = ""Producer = ""Produce_Country = ""def make_success(self):print("生成了一辆小汽车","\n名字:" + self.Name,"\n品牌:" + self.Brand,"\n生产商:" + self.Producer,"\n产地:" + self.Produce_Country,"\n",)
# 一个类中同一方法只能生效最后一次定义。
""" 初始化函数与构造函数 括号内不加参数时函数内def __init__():brand = self.carnameprint("生成了一辆小汽车:222")"""
# -------------------function-----------------------<##-----------------class----------------->#
def mass_produce(number):""" 批量造车 """import randomlis = []i = 0while i < number:i = i + 1j = 0name = ""while j <= 10:name += code[random.randint(0, len(code) - 1)]j = j + 1car = Car()car.Name = namecar.Brand = random.choice((list(brand)))car.Produce_Country = random.choice(produce_country)car.Producer = brand[car.Brand]lis.append(car)return lis
# ---------------------function----------------------<#
numb = int(input("输入生产汽车的数量"))
t = mass_produce(numb)
for i in t:i.make_success()
print("已成功生产", numb, "辆车")

9. 访问限制

#  keyword：“访问限制”，
#  没多大用。。。。。。。# encoding:utf-8class car:""" produce car """
# price: ""
# _brand: ""
# __color: ""def __init__(self):self.price = 4000self._brand = "asdfa"self.__color = "red"
vehicle = car()
print(vehicle.price)
print(vehicle._brand)
print(vehicle._car__color)
vehicle.price = 50
vehicle._brand = "qqqqqqqqqqq"
vehicle._car__color = "aaaaaaaaaa"
print(vehicle.price)
print(vehicle._brand)
print(vehicle._car__color)

10. property

#  keyword：“属性变化”，“装饰器”，“property”# encoding:utf-8class car:"""计算价格"""def __init__(self, door, tie):self.door = doorself.tie = tieself.band_price = 5000.0
#  方法转换为属性@propertydef total_cost(self):"""(door + tie) x 4 + price"""return (self.door + self.tie) * 4 + self.band_price
spend = car(203, 450)
print(spend.total_cost)

11. 文件操作----IO

流程为先打开一个文件（程序中的一个对象），然后对这个对象进行操作。

11.1 打开

通过open方法打开一个文件。对于文件是否存在通过方法的参数指定打开方式。

file=open(file, mode,buffering=1,encoding="utf-8")
file.close()

一定要记得关闭，否则如果是写操作，未关闭则不会写入。如果是读，会一直占用此文件。其他对于此文件的读写操作会被影响，比如删除时会提示文件被占用，无法删除。

file 文件路径。可以使用相对路径或者绝对路径。

mode 文件打开模式。值为以下表所示。

buffering 指定文件是否进行缓存。

encoding=“utf-8” 指定此编码格式打开，默认为 GBK格式打开

mode 值为以下几种值或者他们的组合。

参数如下。

参数值	含义	可组合项
w	指定为写打开。文件存在就覆盖，不存在就创建	~ +，~ b，~ b+
r	指定为只读打开，文件必须已存在。打开后指针在文件开头。	同上
+	扩展 r、w 权限，使 r 可写（从文件头开始覆盖写），使 w 可读（先覆盖，后读写）。
a	以追加形式打开文件操作，打开后指针在文件末尾。	~ +（读写），~ b ，~ b+
b	以二进制的形式进行文件读写。一般用于非文本文件。

11.2 write

file.write(string)

向file中写入string字符串。

必须以 w及w组合 或者 a及a组合 打开，否则会报错。

wf=open("./demo.txt","+w")
wf.write("sdnakjldnvn435746954u83o2abc123")
wf.close()

11.2 read

file.read(size)

从file中读取字符串。

size 读取的数据长度。实际指读取指针的移动距离。未指定为完全读取。

再次使用read会接着上次的位置继续读取。

file.seek(offset[,whence])

指针从whence指定位置开始往后移动offset个字符。

offset 移动的字符长度

whence 开始的位置，默认为0。0为开头，1为当前位置，2为末尾。如果打开方式不是 rb ，则强制为0。

text=file.readline()

读取一行内容。

texts=file.readlines()

读取全部行。返回一个列表。行号为索引。

rf=open("./demo.txt","r")
rf.readline()

11.3 代码示例

以下代码为创建demo.txt文件，然后写入 .... ，再然后读取、输出。

wf=open("./demo.txt","+w")
wf.write("sdnakjldnvn435746954u83o2abc123")
wf.close()
rf=open("./demo.txt","r",buffering=1)
print(rf.read(10))
print(rf.read(10))
rf.close()

12. OS - Path

引入模块import os

判断路径

os.path.exists(path)

判断路径是否存在。返回bool值
创建路径

os.mkdir(path)

创建单级菜单。也就是指定路径的每一级，然后创建最后一层的文件夹。

当最后一级前的部分有不存在的则会报错。所以建议结合exists()

os.makedirs(path)

创建多级菜单，同样指定路径的每一级，任意一级不存在就会创建，直至创建完最后一级。
删除路径

rmdir(path) 删除指定路径，但前提是路径中没有文件。否则会报错。同样，路径不存在也会报错。

如果需要完全删除可使用下方代码
```
import shutil
shutil.rmtree(path)
```
遍历目录

os.walk(top,topdown,onerror,followlinks)
- top 为遍历的路径。
- topdown 布尔值，指定是否为从上到下遍历。默认为true。
- onerror 遍历出现错误时的处理方式，默认为忽略。
- followlinks ---------……
返回一个元组。

三个元素：dirpath，dirnanes，filenames。
- dirpath-- 当前遍历路径。是一个字符串
- dirnames-- 遍历时的所有路径。是一个列表。
- filenames-- 遍历到的文件。是一个列表。

12.5 删除文件

12.6 修改路径与文件名

12.7 获取文件信息