Python 号称是最接近人工智能的语言,因为它的动态便捷性和灵活的三方扩展,成就了它在人工智能领域的丰碑

走进Python,靠近人工智能

一.编程语言Python的基础 之 "浅入浅出"不是不给你讲,而是重点在人工智能应用

1.变量

声明变量:

1 name = "DragonFire" #声明一个变量name 用来存储一个字符串"DragonFire"

2 age = 20 #声明一个变量age 用来存储一个数字 20

3

4 print(name, age) #在控制台打印变量name中存储的字符串 和 变量age中存储的数字 (DragonFire 20)

5 print("name", "age") #在控制台打印字符串"name" 和 "age" (name age)

6

7 #小练习

8 #在控制台打印 name DragonFire age 20

声明变量

2.控制台交互

1 #打开控制台输入模式,输入提示语为"请输入你的名字>>>" 并将用户输入的信息保存在username变量中

2 username = input("请输入你的名字>>>")3

4 #在控制台打印变量username所存储的数值

5 print(username)

#小例子

username = input("你叫什么名字? >>>")print("你好!",username,"我是Python程序")

3.逻辑运算

#== , != , <= , >= , < , > 逻辑运算符

print(1 == 1) #真

print(1 == 2) #假

print(1 != 2) #真

print(1 != 1) #假

print(1 <= 2) #真

print(1 >= 2) #假

print(1 < 2) #真

print(1 > 2) #假

#思考题

print(1 == "1") #真 还是 假

#与或非

print(1 == 1 and 2 == 2) #真 and 真 = 真

print(1 == 1 and 1 == 2) #真 and 假 = 假

print(2 == 1 and 1 == 2) #假 and 假 = 假

print(1 == 1 or 2 == 2) #真 or 真 = 真

print(1 == 1 or 1 == 2) #真 or 假 = 真

print(2 == 1 or 1 == 2) #假 or 假 = 假

print(not 1 == 1) #not 真 = 假

print(not 1 == 2) #not 假 = 真

4.流程控制

#流程控制 之 if else 判断

if 1 == 1: #如果 if 跟随的条件 为 真 那么执行属于 if 中的语句

print("真的")if 1 == 2: #如果 if 跟随的条件为 假 那么不执行属于if 的语句,然后寻找 else

print("假的")else: #寻找到 else 之后 执行属于else中的语句

print("1==2 假的")#高端判断 之 否则如果:

if 1==2:print("1==2")elif 1==1 : #如果 if 条件不成立,会进行第二次判断 elif ,如果elif条件成立,则执行属于elif中的语句,如不成立则else

print("1==1")else:print("全是骗人的")

做一个用户登录小例子:

#综合上述知识,我们做个小练习

username = input("输入用户名:")

pwd= input("输入密码:")if username == "123" and pwd == "111":print("欢迎登陆")

流程控制 之 循环

#讲道理它应该是从头到尾的 for 循环

for i in range(10): #从0开始循环到9

print(i)

#带条件的While 循环,讲道理它根本不会自己停下来

while 1==1 : #如果while 的条件成立,则运行属于while中的语句,直到条件不成立为止

print("你好")#劝你不要尝试

主动停止当次或者终止循环

#循环中带着判断 , 你好我是continue , Hello 我是 break

for i in range(10):if i == 5: #当 i 为5 时

continue #停止当次循环回到最开始继续循环

if i == 7: #当 i 为 7 时

break #停止全部循环

print(i)#打印结果显而易见,不会显示5 当遇到7 的时候不会打印,并且程序结束 也就是 0,1,2,3,4,6

特殊的while循环

i =0

flag=True#while循环的停止方式有两种

whileflag :

i= i + 1

if i == 5:continue

if i == 7:

flag= False #第一种停止方式就是让while 的条件不成立

if i == 9:break #第二种停止方式就是 break

结合循环,再做一个用户登录的例子:

#用户名密码错误,就重复输入到正确为止

whileTrue:

username= input("输入用户名:")

pwd= input("输入密码:")if username == "123" and pwd == "111":print("欢迎登陆")break

else:continue

5.数据类型

int 整型:不带引号的整数数字,正负都可以取值范围: 32位操作系统 : -2147483648 至 2147483648  64位操作系统: -9223372036854775808 至 9223372036854775807

num = 1 #声明一个int型变量num 并赋值为 1

print(type(num)) #打印变量num的类型# 类型为"int"

float 浮点型 : 不带引号的小数,正负都可以但是长度有限制取值:

num = 1.2 #声明一个float型变量num 并赋值为 1.2

print(type(num)) #打印变量num的类型# 类型为"int"

布尔型 : 也可以叫真假值,就是之前用来判断真假的 True 和 False

boo = True #声明一个 bool 型变量 boo 并赋值为 True

print(type(boo)) #打印变量 boo 的类型# 类型为"bool"

字符串 : 带引号里面写的基本上都是字符串"这就是个字符串儿"

string = "Oldboy Edu" #声明一个 string 型变量 str 并赋值为 Oldboy Edu

print(type(str)) #打印变量 string 的类型# 类型为"str"

#字符串类型中的操作:#字符串索引:

print(string[0]) #提取第一个字符

print(string[-1]) #提取最后一个字符

#字符串切片

print(string[0:4]) #提取第一个到第四个字符

#字符串拼接:

print("你好 %s"%(string)) #你好 Oldboy Edu %s 被 string 替换

#字符串分割:

print( string.split(" ") ) #使用空格分割

#字符串去除空格

print( string.strip() )

列表 : 被中括号 [] 包裹 , 内部用逗号分隔元素 [1, 2, 3, "4"]

l = [1, 2, '3', ["a", "b"]] #声明一个 l 型变量 list 并赋值为 [1, 2, '3', ["a", "b"]]

print(type(l)) #打印变量 l 的类型# 类型为"list"

#列表的操作:#列表索引:

print(l[0]) #提取第一个元素

print(l[-1]) #提取最后一个元素

#列表切片

print(l[0:4]) #提取第一个到第四个元素

#添加元素

l.append("123") #在列表的尾端插入

print(l)#删除元素

l.pop(0) #删除第一个元素

print(l)

l.remove('3') #删除列表中的某一个元素

print(l)#列表的特殊用途:#遍历列表

for item in l : #每循环一次,从列表中拿出来一个元素

print(item)#列表包含

if 2 in l : #2 in l 返回True 代表 2 存在于 l 中 反之 False

print(l)

元组 : 和列表几乎一样,只不过把中括号[] 换成了 () 并且 元组不能被修改,也就是不能添加和删除元素

t = (1, 2, '3', ["a", "b"]) #声明一个 t 型变量 tuple 并赋值为 (1, 2, '3', ["a", "b"])

print(type(t)) #打印变量 t 的类型# 类型为"tuple"

#元组的操作:#元组索引:

print(t[0]) #提取第一个元素

print(t[-1]) #提取最后一个元素

#元组切片

print(t[0:4]) #提取第一个到第四个元素

#元组的特殊用途:#遍历列表

for item in t : #每循环一次,从元组中拿出来一个元素

print(item)#元组包含

if 2 in t : #2 in l 返回True 代表 2 存在于 l 中 反之 False

print(t)

字典 : 就是键值对的存储,键值对-- k : v 字典{k1:v1,k2:v2} ,key不可重复,且无序

dic = {"name": "DragonFire", "age": 20} #声明一个 dict 型变量 dic 并赋值为 {"name": "DragonFire", "age": 20}

print(type(dic)) #打印变量 dic 的类型# 类型为"dict"

#取值:

print(dic["name"]) #打印 dic 中 name 对应的值

print(dic.get("name")) #如果dic中没有name不会抛出异常

#修改:

dic["name"] = "Long"

print(dic)#增加:

dic["gender"] = "man"

print(dic)#删除:

del dic["gender"]print(dic)#字典的特殊用法:#循环

for k,v in dic.items(): #分别将字典的key和value拿出来

print(k,v)

集合 : 可以理解为只有Key的字典,不可重复,并且无序

s = {"name", "DragonFire", "age", 20} #声明一个 set 型变量 s 并赋值为 {"name", "DragonFire", "age", 20}

print(type(s)) #打印变量 dic 的类型# 类型为"set"

#添加元素

s.add("1234")print(s)#删除元素

s.remove(20)print(s)

s.pop()#随机删除一个

print(s)#set 是不能通过索引的方式取值的,但是可以通过for遍历的方式取值

for i ins:print(i)#set 的特殊用法#求交集

l = ["name",1,2,20]print(s.intersection(l)) #可以获得交集

二.Python语言的进阶 之 这里学会了Python就会了70%

1.函数 : 你那么聪明根本都不需要看这个章节 之 def args kwargs

1 def func(参数1,参数2): #def 用来定义函数及函数名,参数1和参数2就是定义时的形参,也就是将来调用函数时必须要传入的参数

2 变量1 = 参数1+参数23 return 变量1

如果你看了并且还想点开看的话 + 看了就要记住不然别看

1 #我们定义参数的时候,无法确定函数中会有多少参数时,需要可变长参数,也就是动态参数的参与处理 这里我们的*args 和 **kwargs 就起了作用

2

3 *args 就是 将未定义且多余的 位置参数记录在内,偷偷的告诉你,args是个元祖,里面记录着你个函数传递的多余位置参数4

5 **kwargs 就是 将多余的关键字参数记录在内,我用嘹亮且带有磁性的声音,偷偷告诉你,kwargs 其实是个dict哦,里面大概就是{"name":"Dragon","age":1+1+1+1+1+1+18}

你总是这么变来变去的我都不爱你了 + *args **kwargs

1 def args_func(a,b,*args): #args 里面保存着除了ab之外的所有多余参数

2 print(args) #这回知道是元祖了吧

3 for i inargs:4 print(i)5

6 args_func(1,2,3,4,5,6) #这里调用的时候1,2分别传递给a,b,那么3456就会保存在args里面哦

*args 的糖炒栗子

1 def kwargs_func(a, b, **kwargs): #kwargs 里面保存着除了ab之外其他关键字传入参的参数

2 print(kwargs) #这回知道是字典了吧

3 for k, v inkwargs:4 print(k, v)5

6

7 kwargs_func(1, 2, c=3, d=4, e=5) #这里调用的时候,12分别传递给a,b 那么c=3,d=4,e=5 就会保存在**kwargs里面哦

**kwargs 的 北京怀柔大板栗

1 def args_kwargs_func(*args, **kwargs): #这里一定要注意*args 要在 **kwargs之前

2 print(args)3 print(kwargs)4

5

6 args_kwargs_func(1, 2, a=1, b=2) #12存入args a=1,b=2 存入kwargs,这里要注意的是关键字传参之后,不可以在位置传参了

*args **kwargs 的 糖炒北京怀柔大板栗

本节结束,忘记它吧

2.推导而不是推倒 之 推导式

推导式举两个怀柔大板栗:

列表推导式:很(yao)重(xue)要(hui)

1 li = [i for i in range(10)] #简单的列表推导式,就是在列表内写一个for循环对吧

2 print(li) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3

4 lis = [i for i in range(10) if i % 2 == 0] #这是带if 条件的列表推导式

5 print(lis) #[0, 2, 4, 6, 8]

超级简单 + 学不会的开启while模式

生成器推导式 : 也(te)很(bie)重要

1 gener = (i for i in range(10)) #简单的生成器推导式,就是在元组内写一个for循环对吧

2 print(gener) # at 0x04F9B3C0>

3

4 geners = (i for i in range(10) if i % 2 == 0) #这是带if 条件的生成器推导式

5 print(geners) # at 0x04F9B3F0>

别以为我只是复制粘贴的 + 让你一点儿毛病也挑不到

从上述来看,列表推导式和生成器推导式只是[] 与 () 的区别

但是实际上,生成器推导式的效率非常高,但可控性很差,比如不直观,用一次就没了

相对而言列表推导式的效率比较低,但是可控性强,可以反复利用,而且数据显示很直观

本节及本章结束,内容较多,希望大家,都(bi)能(xu)学会

3.模块

import 的用法

字符串字符串字符串 之 json 模块

只要你是个说得上名的数据类型,我全给你弄成字符串,就问你服不服

1 importjson2

3 #我们做一个字典

4 dic ={5 "name": "Dragon",6 "age": 20,7 "hobby": ["摩托车", "骑车"],8 "other": {9 "say": "hello",10 "see": "beautiful girl",11 }12 }13 json_dic = json.dumps(dic) #json序列化

14

15 print(type(json_dic), json_dic)16

17 # {"name": "Dragon", "age": 20, "hobby": ["\u6469\u6258\u8f66", "\u9a91\u8f66"], "other": {"say": "hello", "see": "beautiful girl"}}

18

19 loads_dic = json.loads(json_dic) #json 反序列化

20

21 print(type(loads_dic), loads_dic)22

23 # {'name': 'Dragon', 'age': 20, 'hobby': ['摩托车', '骑车'], 'other': {'say': 'hello', 'see': 'beautiful girl'}}

一个神奇 json 有了它把一切不可能变为可能

json 用于数据传输上,非常的爽

兄弟就靠你了 之 os 模块

os 模块其实是集成了很多操作系统的方法,比如创建文件夹,拼接路径,删除文件,创建文件等等

importos

os.path.join("a","b") #组合路径 a/b

os.system("ls") #执行系统命令

os.sep() #获取当前操作系统的路径分隔符

os.path.dirname(__file__) #获取当前文件的所在目录

importos

os.getcwd()#获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname") #改变当前脚本工作目录；相当于shell下cd

os.curdir() #返回当前目录: ('.')

os.pardir() #获取当前目录的父目录字符串名：('..')

os.makedirs('dir1/dir2') #可生成多层递归目录

os.removedirs('dirname1') #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname') #生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname') #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname') #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove("file_name") #删除一个文件

os.rename("oldname", "new") #重命名文件/目录

os.stat('path/filename') #获取文件/目录信息

os.sep() #操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep() #当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

os.pathsep() #用于分割文件路径的字符串

os.name() #字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command") #运行shell命令，直接显示

os.environ() #获取系统环境变量

os.path.abspath(path) #返回path规范化的绝对路径

os.path.split(path) #将path分割成目录和文件名二元组返回

os.path.dirname(path) #返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path) #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path) #如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path) #如果path是绝对路径，返回True

os.path.isfile(path) #如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path) #如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间

4.文件操作

f = open("123.txt","rb") #打开文件句柄

print(f.read()) #读取文件内容

f.close() #关闭文件句柄

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r ，只读模式【默认】

w，只写模式【不可读；不存在则创建；存在则清空内容；】

x， 只写模式【不可读；不存在则创建，存在则报错】

a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

r+， 读写【可读，可写】

w+，写读【可读，可写】

x+ ，写读【可读，可写】

a+， 写读【可读，可写】

"b"表示以字节的方式操作

rb  或 r+b

wb 或 w+b

xb 或 w+b

ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

#文件上下文操作

with open("123.txt","rb") as f: #文件句柄f 自动打开关闭文件句柄

f.read() #读取文件内容(全部)

with open("123.txt","rb") as f:

f.read()#读取文件内容(全部)

f.readline() #读取文件中一行文件

f.readlines() #读取文件中所有行 ["1","2"]

f.write("666") #写入文件内容

f.writelines("666") #写入一行文件

f.flush()#刷新文件

f.seek(10) #移动光标到10位置

f.truncate(6) #从光标当前位置截取6位

f.tell() #获取当前光标位置