Python，极其高级的人工智能编程语言，文件后缀名为.py，可以用三方库pyinstaller编译为.exe，就可以运行在任何windows电脑上
先教一个函数
print()打印括号内容在终端上，\n表示换行，关于\的使用请百度“py\的使用”
所以最简单的py代码是：
print('Hallo, world!')
输出结果：Hallo, world
还有一个对应的，input()，它能让用户输入数据，数据类型为字符串
例子：
print('你是' + input('输入你的年龄：') + '岁')
输入你的年龄：15
>>>你是15岁

变量
变量命名只能是字母开头的，严格区分大小写，比如a1和A1和a和A是不同变量，可以有_其他不能乱加，变量可以重新替换赋值，比如a = a + 1，意思不是方程，而是a在原值上加了1
变量赋值举例(>>>表示输出结果)：
djdjdbbx = 1 * 20
dhd = '我是sb' * 2    #即dhd的赋值是 我是sb我是sb ，重复2遍
ab2883 = [123, '569']
a = 1
b = a
c = a + b
a = 0
print(a + b * c)
>>> 2

数据类型
整数（123456），浮点数（小数），字符串（单双引号要成双，且必须为英文符号，如：'187sdjfn',"hello"）等等，基础的人学这些就行
数据类型转换函数（注意不要用中文括号）：
float()整数转浮点数
int()字符串浮点数转整数（像'djd'转不了，这种'28383'才得）
str()整数浮点数转字符串
例子：int('738929')
a = int(3.1415926)
# 井号之后的代码不会被运行，一般用作注释代码
# 此时a变为3
k = '你' + '好'
print(k)
>>>你好

单多分支语句（条件语句）
Python 编程中 if 语句用于控制程序的执行，基本形式为（缩进一次为4个空格）：
if 判断条件:
     语句1……
else:
     语句2……
当if判断正确则执行语句1，不正确则执行语句2

由此又有多分支语句
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）、!=（不等于）来表示其关系。
当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
    语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
……
else:
    执行语句4……

例子：
while True:
    a = int(input('直角边1：'))
    b = int(input('斜边：'))
    c = int(input('直角边2：'))
    d = a * a
    e = c * c + d
    f = b * b
    if a == b and b == c and a == 0:
        print('sb.cnm')
    elif e == f:
        print('这是直角三角形')
    else:
        print('这不是直角三角形')
这是个小小的例子，while循环之后会讲到，你就当这中间的都会循环进行就行，中间运用了勾股定理

循环语句
循环一般有for循环和while循环，可以用break打破
while循环基本结构：
while 判断条件:
    语句……
当条件一直正确，语句就会反复执行（当然我们可以使用布尔值True，False[一定要大写]来代替条件，其中，可以用1代替True，用0代替False）
举例：
i = 5
while i != 0:
    print(i)
    i = i - 1
>>>5
>>>4
>>>3
>>>2
>>>1

for循环语句基本结构：
for 变量 in 语句:
    语句
例如：（range()函数表示列表比如range(3)即[0, 1, 2]即从0到这个数，但不包括这个数）
for i in range(5):
    print(i)
>>>0
>>>1
>>>2
>>>3
>>>4
如果直接print(range(5))会是[0, 1, 2, 3, 4]

break使用
while 1 == 1:
     if 1 != 2:
        break    #在这里已经跳出循环所以下一句不会被执行
        print()

函数与模块
重点！！！
函数分为内置函数、自定义函数和三方函数，内置函数是python语言自带的，三方的则是别人开发出来导入用的，自定义函数是你自定义出来你导入或直接使用的，像print()等如上都是内置函数
模块也如此，分为内置和三方，内置直接导入就行，三方可能是自己的，也可能是别人的，别人的需要用pip工具（py自带）下载，有兴趣可百度，自己的的话，每一个xxx.py文件都可以当成一个模块，模块又叫做库，模块导入后可以使用这个库里的函数和变量

函数，和数学里的sin()和cos()一样，就是一串字母加括号，对括号里的东西进行某种运算或者功能，单独表示一个东西。打个比方像根号二，也是运算，但是结果不能用正常点的数表示，就单独是一个数……
例子：print(5)     >>>5

模块，导入方法有如下：
import sys
import sys as y    #这里指导入sys模块并给它取小名，取小名之后只能用小名y来使用该模块，不能用sys
from sys import exit    #单独导入sys模块的exit()函数，避免一下导入太猛卡顿，减少运行负担

比如内置模块，sys的exit()函数可以安全退出程序，括号里为安全退出时打印的数据
示例：
import sys as dsb
dsb.exit('已退出，之后的代码不会执行')
print('我不会被执行！')
>>>已退出，之后的代码不会执行
编程路上需要大量模块与函数，因此其十分重要

自定义函数格式：
def 函数名(参数):
    语句
参数就是像print(5)一样，5就是其中的参数，参数可有很多个
当自定义函数时使用return xxxxxxx的时候，意思大概可以理解为这个函数运行到这种时候它表示的就是这个xxxxxxx
举例：
def sb(a, b):
    c = a * b - 4
    return c
print(sb(5, 6))
>>>26

列表
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，注意，从头是0开始，比如：
          0  1  2
list = [1, 2, 3 ]
如下所示：
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print(list1[0])
print(list2[1:5])
>>>physics
>>>[2, 3, 4, 5, 6]
更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项

Python 元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print(tup1[0])
print(tup2[1:5])
>>>physics
>>>(2, 3, 4, 5, 6)

神奇的Pass
Pass语句，等于屁都没有
什么意思呢
举个例子
我不会写
for i in range(3):
    if i == '2':
        break
    print(i)
>>>0
>>>1
我可以写
for i in range(3):
    if i !='2':
        pass
    else:
        print(i)
>>>0
>>>1
输出结果一样，但是多了一点点
也就是说，比如if必须后面要跟语句块，但是你一时脑子没转过这个弯，忘记怎么写了，就在if后语句块用pass，不然会报错提示if后一定要跟语句块

字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
很好用的一个东西
字典的值可以单独访问或者修改，类似面向对象，格式是   字典名[键]
t = {'a': 1, 'b': 2, 'b': '3'}
print(t['b'])
>>>2
修改字典也差不多，非常好理解。
t = {'a': 1, 'b': "2", 'b': '3'}
t['a'] = 3
t[7] = 6
print(t)
>>>{'a': 3, 'b': "2", 'b': '3', 7: 6}
像我们QQ账号密码在服务器的储存我猜大概率也是以字典形式存在的，比如：{1945581559: 'abc123456', 1838299768: 'lgy5201314lfy', ………………………}，只是不同编程语言的字典修改也不同，QQ的语言应该是JavaScripts

File文件处理
格式一般是打开-干活-关闭，两种（实际上不知两种）主流的打开方式，我都教吧
第一种：
f = open('文件名.后缀名', '打开模式')
f.功能(参数)
f.close()
第二种：
withopen('文件名.文件后缀名', '模式') as f:
    f.功能(参数)
    f.close()
打开模式有几种，新手背标星的就行：
t    文本模式 (默认)
x    写模式，新建一个文件，如果该文件已存在则会报错
b    二进制模式
+    打开一个文件进行更新(可读可写)*******
U    通用换行模式（不推荐）
r     以只读方式打开文件，文件的指针将会放在文件的开头*******
rb   以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等
r+   打开一个文件用于读写。文件指针将会放在文件的开头
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。w打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
wb  以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等
w+   打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
wb+  以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等
a   打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入*******
ab  以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
a+  打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。****
ab+  以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写

一般就用a，r，w，+，除非你学python为了爬虫，爬了音乐图片视频写入东西就要用二进制写入和读取
那么，刚才的两种方法，一般用第一种，我举个例子
f = open('test.txt', 'a')
f.write('12345')
f.close()
k = open('test.txt', 'r')
aaa = k.read()
print(aaa)
k.close()
>>>12345
一定要关闭文件close()！！！不然就会像你的U盘一样异常关闭而损失文件！！

try...except...
异常处理，比如你怕你的用户在使用程序时东搞西搞，因为报错会跳出文件嘛，像电脑QQ有时候就会突然出现一只屎壳郎错误报告，这样你的程序如果正在编制缓存文件，容易泄露东西或者导致重新启动会异常（打开缓存文件出错啊等等），所以我们用try可以跳过错误，当程序遇到错误了立马跳过代码补救，这样就不会退出程序。
举个小小的有点小用的例子：
while True:
     f = open('1.py', 'w')
     try:
         yonghushuru = int(input('请输入一个不为零的整数！'))
         f.write(100/yonghushuru)
         f.close()
         break
     except:
         f.close()
         print('请正常输入！！！')
我们看，因为int并用100除以(/)用户输入 的存在，我们必须要让用户输入的不是0也不是文字，但如果用户真的那么做，就会报错，所以加入了while和try，当用户只要不那么做就正常关闭程序并重复执行程序，直到他干正事为止，避免了错误的发生！！！

面向对象
只要你不开发模块或者框架，劝你别学，耗时长作用小，省流：一黑到底

正则表达式
重头戏来啦！！！
以上教的你甚至考不了1级，因为1级涉及海龟模块，但是正则表达式是大约python5级的内容，新手看懂率15%
来吧，展示！
大家想一想
要知道，如果你开发网络爬虫，面对海量的数据与海量的html、php、js文档，你明明已经搞到文件，但你想从中捞出所有网址，怎么做？
正则表达式！
那么，复杂的东西我们就举一个小小的例子：如何在"01-00-00-01"中提取出"01000001"呢？
根据需求，不难看出是去掉所有的“-”，那按照举一反三"1"+"2"="12"可以有"1234"-"2"="134"吗？没有！
这时候就要用到re正则表达式库！

re.match函数
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。
函数语法：
re.match(pattern, string, [flags])
其中，pattern: 模式字符串   string:要被匹配的字符串   flags:可选参数,如下：
I = IGNORECASE # 忽略大小写
L = LOCALE     # 字符集本地化,为了支持多语言版本的字符集使用环境
U = UNICODE    # 使用\w,\W,\b,\B这些元字符时将按照UNICODE定义的属性
M = MULTILINE  # 多行模式,改变 ^ 和 $ 的行为
S = DOTALL     # '.' 的匹配不受限制,包括换行符
X = VERBOSE    # 冗余模式,可以忽略正则表达式中的空白和#号的注释

匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

小小的例子：
import re
#1.开始位置不匹配
res = re.match("ang","zhangsan")
print(res)
>>>None
#2. 匹配到结果
res = re.match("ang","angsan")
print(res) #单纯打印对象
>>><_sre.SRE_Match object; span=(0, 3), match='ang'>
print(res.group()) #获取匹配到的数据
>>>ang
#3.是否区分大小写匹配对比
res = re.match("ang","Angsan")
print(res)
>>>None
res = re.match("ang","Angsan",re.I) #加上re.l后不区分大小写！
print(res) #单纯打印对象
>>><_sre.SRE_Match object; span=(0, 3), match='Ang'>
print(res.group()) #获取匹配到的数据
>>>Ang
上面这个例子非常好理解的！


下一个例子（改自菜鸟编程，由py2变为py3的写法）：
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I) #最后面的参数表示不区分大小写并多行模式
if matchObj:
    print(matchObj.group())
    print(matchObj.group(1))
    print(matchObj.group(2))
else:
    print(No match!)
>>>Cats are smarter than dogs
>>>Cats
>>>smarter
解析：首先，这是一个字符串，前面的一个r表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个r可有可无
(.) 第一个匹配分组，. 代表匹配除换行符之外的所有字符。
(.?) 第二个匹配分组，.? 后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符
后面的一个 .* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。
matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符
matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的
matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的
因为只有匹配结果中只有两组，所以如果填 3 时会报错
不是很好理解，多看几遍就懂了！！提示：第一个参数刚开始我也搞不懂，但是我懂了后总结是：因为这一个字符串内可以放多个的关键词，所以一堆符号也像解析一样分别代表4个关键词中3个条件（因为are就是are，不必当一个条件，当一个过河桥就好），什么意思呢？第一个打印是把整个句子提取了，后面的说白了就是“啥 are 啥”在“Cats are smarter than dogs”中第一个啥和第二个啥分别代表什么，打印的就是Cats和smarter！！

正则语法（元字符）
1、？：前面的内容出现0-1次
2、+ ：前面的内容出现1-多次
3、* ： 前面的内容出现0-多次
4、^： 匹配开始
5、$: 匹配结尾
6、|：管道符！ 或
7、使用管道符，加上小括号！()
8、\d： 匹配数字 代表1个数字！
9、\D: 匹配非数字
10、word：普通字符
\w: 普通字符 字母，数字 … 一个普通字符
\W: 匹配非普通字符 *)$@^#
11、\s: 匹配空格
\S： 匹配非空格

那么最原始的问题，如何在01-00-00-01中提取01000001呢？？？
import re
text = '01-00-00-01'
pattern = r'\d+'
match_obj = re.findall(pattern, text)
ma = ''
for i in (match_obj):
    ma = ma + i
print(ma)
>>>01000001

为什么这里又在os模块里换了个函数？？
因为re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None，而到了第一个“-”直接罢工……；而re.search匹配整个字符串，直到找到一个匹配。
但是search只匹配出第一个就告辞了！！！
那如果后面其实还有，想找全怎么办？
os.findall函数将以列表形式完全扒出，再使用for循环就可以啦！
例如：
import re
text = 'The values are 1, 2, and 3.'
pattern = r'\d+'
match_list = re.findall(pattern, text)
print(match_list)
ma = ''
for i in match_list:
    ma = ma + i
print(ma)
>>>['1', '2', '3']
>>>123

非常好用！……什么？你觉得还是太长了？
试试这个！
re.finditer()
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
import re
it = re.finditer(r"\d+","12a32bc43jf3")
for i in it:
    print(i.group())
>>>12
>>>32
>>>43
>>>3

检索和替换
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

刚才那个01000001，其实还有一个方法，不是找出需要的，而是删除多余的
sub可以删除多余的
例子：
import re
phone = "01-00-00-01 **## 这是一串神秘数字"
# 删除字符串中的 Python注释和文字，还剩下普通符号（忘了可以看上边的笔记）
s = re.sub(r'#.*$', "", phone)
print(s)
# 删除非数字(-)的字符串
s = re.sub(r'\D', "", phone)
print(s)
>>>01-00-00-01 **
>>>01000001

至此，Python所有编程基础教程就教完啦！剩下的就交给模块啦！拜拜！

©CopyRights 2023 zhs141.github.io, zhouhangshan.github.io
版权所有，爱抄就抄。