Python 号称是最接近人工智能的语言,由于它的动态便捷性和灵活的三方扩展,成就了它在人工智能领域的丰碑python
走进Python,靠近人工智能shell
一.编程语言Python的基础 之 "浅入浅出"不是不给你讲,而是重点在人工智能应用编程
1.变量json
声明变量:bash
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.控制台交互app
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.流程控制ide
#流程控制 之 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("欢迎登录")
流程控制 之 循环post
# 讲道理它应该是从头至尾的 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循环的中止方式有两种 while flag : i = i + 1 if i == 5: continue if i == 7: flag = False # 第一种中止方式就是让while 的条件不成立 if i == 9: break # 第二种中止方式就是 break
结合循环,再作一个用户登陆的例子:
# 用户名密码错误,就重复输入到正确为止 while True: 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的类型 # <class 'int'> 类型为"int"
float 浮点型 : 不带引号的小数,正负均可以可是长度有限制取值:
num = 1.2 #声明一个float型变量num 并赋值为 1.2 print(type(num)) # 打印变量num的类型 # <class 'float'> 类型为"int"
布尔型 : 也能够叫真假值,就是以前用来判断真假的 True 和 False
boo = True #声明一个 bool 型变量 boo 并赋值为 True print(type(boo)) # 打印变量 boo 的类型 # <class 'bool'> 类型为"bool"
字符串 : 带引号里面写的基本上都是字符串"这就是个字符串儿"
string = "Oldboy Edu" #声明一个 string 型变量 str 并赋值为 Oldboy Edu print(type(str)) # 打印变量 string 的类型 # <class 'str'> 类型为"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 的类型 # <class 'list'> 类型为"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 的类型 # <class 'tuple'> 类型为"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 的类型
# <class 'dict'> 类型为"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 的类型
# <class 'set'> 类型为"set"
#添加元素
s.add("1234")
print(s)
#删除元素
s.remove(20)
print(s)
s.pop() #随机删除一个
print(s)
# set 是不能经过索引的方式取值的,可是能够经过for遍历的方式取值
for i in s:
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+参数2 3 return 变量1
1 #咱们定义参数的时候,没法肯定函数中会有多少参数时,须要可变长参数,也就是动态参数的参与处理 这里咱们的*args 和 **kwargs 就起了做用 2 3 *args 就是 将未定义且多余的 位置参数记录在内,偷偷的告诉你,args是个元祖,里面记录着你个函数传递的多余位置参数 4 5 **kwargs 就是 将多余的关键字参数记录在内,我用嘹亮且带有磁性的声音,偷偷告诉你,kwargs 实际上是个dict哦,里面大概就是{"name":"Dragon","age":1+1+1+1+1+1+18}
1 def args_func(a,b,*args): # args 里面保存着除了ab以外的全部多余参数 2 print(args) # 这回知道是元祖了吧 3 for i in args: 4 print(i) 5 6 args_func(1,2,3,4,5,6) # 这里调用的时候1,2分别传递给a,b,那么3456就会保存在args里面哦
1 def kwargs_func(a, b, **kwargs): # kwargs 里面保存着除了ab以外其余关键字传入参的参数 2 print(kwargs) # 这回知道是字典了吧 3 for k, v in kwargs: 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里面哦
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,这里要注意的是关键字传参以后,不能够在位置传参了
本节结束,忘记它吧
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]
生成器推导式 : 也(te)很(bie)重要
1 gener = (i for i in range(10)) # 简单的生成器推导式,就是在元组内写一个for循环对吧 2 print(gener) # <generator object <genexpr> at 0x04F9B3C0> 3 4 geners = (i for i in range(10) if i % 2 == 0) # 这是带if 条件的生成器推导式 5 print(geners) # <generator object <genexpr> at 0x04F9B3F0>
从上述来看,列表推导式和生成器推导式只是[] 与 () 的区别
可是实际上,生成器推导式的效率很是高,但可控性不好,好比不直观,用一次就没了
相对而言列表推导式的效率比较低,可是可控性强,能够反复利用,并且数据显示很直观
本节及本章结束,内容较多,但愿你们,都(bi)能(xu)学会
3.模块
import 的用法
字符串字符串字符串 之 json 模块
只要你是个说得上名的数据类型,我全给你弄成字符串,就问你服不服
1 import json 2 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 # <class 'str'> {"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 # <class 'dict'> {'name': 'Dragon', 'age': 20, 'hobby': ['摩托车', '骑车'], 'other': {'say': 'hello', 'see': 'beautiful girl'}}
json 用于数据传输上,很是的爽
兄弟就靠你了 之 os 模块
os 模块实际上是集成了不少操做系统的方法,好比建立文件夹,拼接路径,删除文件,建立文件等等
import os os.path.join("a","b") # 组合路径 a/b os.system("ls") # 执行系统命令 os.sep() # 获取当前操做系统的路径分隔符 os.path.dirname(__file__) # 获取当前文件的所在目录
import os 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() # 获取当前光标位置