人工智能python快速入门
五.python数值运算
(1)加减乘除
乘法(*)：乘法运算
除法(/)：会得到带小数的商。
取余(%)：取余数
平方(**)：平方的意思，例2**3=8
(2)类型转换
1)类型名(变量名)，例如a=5;float(a)或float(5)
2)只有全是数字组成的字符串才能转成int类型，否则转换不成功。
(3)python中把数值可直接赋值给某个变量，变量名前可不指定类型，例a=1;又例如b=True;
然后用type(变量名)就可得出这个变量的类型。
(4)计算先后顺序先算()——>平方——>乘除——>加减
(5)基本数值操作
1)abs()：取绝对值，例abs(-10)
2)round()：四舍五入操作
3)min()：最小值
4)max()：最大值
六.python字符串操作
(1)方法
1)len():计算字符串的长度
2)字符串*数字表示复制多少次(数字)这样的字符串，例a=abc;print(a*3)就等以abcabcabc
3)split():对字符串按什么格式切分，得到一个list。例a='1;2;3'; a.split(';')
4)join():合并。能切就能合。例如a='1;2;3'; b=a.split(';'); c=''; c.join(b)
5)replace():替换
6)strip():去掉左右两边空格
7)lstrip():去掉左边空格
8)format():按格式直接传参数值进来。例'{}{}'.format('a','b');
指定参数顺序值传入进来，例如print('{1}{0}'.format('a','b'));的结果会’b a'
不但可用数字指定参数顺序，还可直接放形参，例如print('{a}{b}'.format(a=1,b=2));的结果会’1 2'
9)也可用%形式达到8)的效果，例如a='abc';b=100.12; '%s %f' %(a,b);
七.索引结构
索引下标都是从0开始计算的，但从后面开始数的话就没有负零开始的，是从-1开始数的。索引不能越界，否则会报错。
(1)索引从左往右数时，第一个是索引0 。例a='abc def'; a[2]会打出c
(2)切片。
用冒号(:)做切片，规则是左闭右开。
1)这里用冒号(:)表示从那里到那里，但它是左闭右开区间的(右边最后那个是不包括的)。例如a='abc de fgh'; print(a[0:3]);这样会打出'abc'，这里它不包括c后面的空格的。又例如
b='abc de fgh'; print(b[1:-3]);这里-3是指从后面算起。
2)如果冒号(:)后面不指定说明后面的内容都取。例如a='abc de fgh'; print(a[4:]);
3)同理，如果冒号(:)前面不指定说明前面的内容都取。例如a='abc de fgh'; print(a[:6]);或print(a[:-2]);
4)那如果冒号(:)两边都不指定值，就等以取全部了
5)如果是两个冒号(::)后接上数字，就是说每隔几隔(数字是几就几，空格也是要算1隔的)取一个值。例如a='abc def this';print(a[::2]);就会打印出acdfti
八.List基础结构
用[ ]表示创建list结构，里面可放任何类型的元素，不一定只固定放一种类型。
(1)用中括号[ ]定义与初始化list。a=[1,2,3];type(a);表示a是定义出了一个list结构，并初始化了1,2,3这三个值放入里面。又例如a=[1,'abc',3];也可以按创建对象方式这种写法，例如a=list([1,2,3,4,5])
(2)操作
1)len()：表示list的长度。例如a=[1,'abc',3];len(a);
2)加号(+)：可把list中的元素拼接在一起构成新的list。例a=[1,'abc',3];b=[21,'c',35];print(a+b);
3)乘号(*)：与字符串操作一样，起到复制里面的元素几次。例a=[1,'abc',3];b=a*2;print(b);
4)通过索引直接取list中的元素，不能越界。例a=[1,'abc',3];print(a[1]);
5)切片。用冒号(:)来切list中元素，这与上面说的七中的索引切片类似。例a=[1,'abc',3];print(a[1:]);
6)赋值。按索引值找到相应位置值，然后用等以赋给新值。例如a=[1,'abc',3];a[1]=123;print(a);全部替换也可以用冒号那种形式，但原来有多少个元素，整体全部替换时也要替换多少个元素(不能多也不能少)。例如a=[1,'abc',3];a[:]=[123,456,789];print(a);
7)del：按指定索引进行删除。例如a=[1,'abc',3];del(a[1]);print(a);也可以用冒号(:)表示从那里开始删除至那里。例如a=[1,'abc',3];del(a[:1]);print(a);
8)in或not in：用来做逻辑判断。即判断某个元素是否在list里面。例如a=[1,'abc',3];3 in a;
九.List核心操作
(1)list中嵌套list：因为list里面的元素是可以任意类型的。例如a=[1,'abc',[123,456],3];print(a[2]); print(a[2][1]); 这样相当于这个a是二维的。
(2)count()：计数操作。例如a=[1,'abc',1,3,'abc','abc'];print(a.count('abc'));
(3)index():由元素值定位得到索引值，但元素值须在list中存在，否则会报错。例如a=[1,'abc','13'];print(a.index('13'));
(4)append():每次向list最后面增加一个任意元素(当然也可加一个list)。例如a=[1,'abc','13'];print(a.append(['13',456,'qqq']));
(5)insert(索引值,插入的元素)：在指定索引位置处增加一个任意元素。例如a=[1,'abc','13'];print(a.insert(1,['13',456,'qqq']));
(6)remove(元素值):删除某个元素值，如果有多个相同元素值，它每次会删除第一个元素。
(7)sort()或sorted():排序。例如a=[1,3,2,8,6];print(a.sort());b=[1,3,2,8,6];b1=sorted(b);print(b1);
(8)reverse()：对list中元素进行反转操作。例如a=[1,'abc','13'];print(a.reverse());
(9)pop(索引值)：弹出指定索引对应的值，弹出后list中就不会存在这值了
十.字典基础定义
字典是key-value结构的，一个字典中key是唯一的，定义后的元素是没有顺序的(每次打印出来的结果看上去位置会发生变化)，这与java的map类似。
(1)用大括号{}定义与初始化字典。也可以按构造对象方式来构造出一个字典。例如a['age']=18;print(a);打印出来的结果是{'age':18};这里中括号里的age是key，18是赋给这个键的值。也可以直接按key-value结构定义到大括号里面，例如a={'age':18,'name':'zhou'}; print(a);
(2)操作
因为字典是key-value结构，那对字典操作就是对这二个值操作。
1)按key查找对应的value值。例如a['age']=18; a['name']='zhou'; print(a['age']);
2)按指定的key进行赋值更新操作。
例如a['age']=18; a['name']='zhou'; print(a['age']);a['age']=100; print(a['age']);
十一.字典的核心操作
(1)字典中的value值也是可以是任意类型的元素的，和list一样。例如a={};
a['age']=18; a['name']=['zhou',1,3]; print(a);同样例如一个字典中可嵌套字典等等。
(2)get(key)或get(key,默认值)：按key键值查找到对应的值。如果键不存在时用get(key,默认值)就会得到默认值，如果用get(key)会报错。
(3)pop(key)：弹出指定key对应的值，弹出后字典中就不会存在这值了。例如a={};a['age']=18; a['name']=['zhou',1,3]; a.pop('name');print(a);
(4)del:删除指定元素。例如a={};a['age']=18; a['name']=['zhou',1,3]; del a['age']
(5)update():用一个字典中的元素更新到旧字典，如果有相同key就更新，如果旧字典中没有key就相当于把这个新元素增加到旧字典中。例如a={};a['age']=18; b={'age':100,'name':['zhou',1,3]}; c=a.update(b);print(c);
(6)in或not in：in是表示某个key是否在字典当中。例如a={};a['age']=18; print('age' in a);
(7)keys:查出所有健值。
例如a={};a['age']=18; a['name']=['zhou',1,3]; b=a.keys();print(b);
(8)values():查出所有values值
例如a={};a['age']=18; a['name']=['zhou',1,3]; b=a.values();print(b);
(9)items():得出字典中所有内容(key与value都得到)。例如a={};a['age']=18; a['name']=['zhou',1,3]; b=a.items();print(b);
十二.Set结构(集合)
Set(集合)是只保留唯一的元素，有去重作用，多个相同元素只保留一个。
(1)构造set与初始化
1)直接把其它类型结构元素通过调用set()方法得到一个set。例如a=[1,'abc','13',1];print(a.set(a));
2)先用set()方法得到一个set对象，然后再赋值。例如a=set(); a=[1,'abc','13',1];print(a);或者直接这样：a=set([1,'abc','13',1]);print(a);它这里传入的是中括号内容[]。
3)set集合也可以直接用大括号{}表示，如果{}里面内容是key-values对，那么是字典；如果不是key-values对，那么是set集合。例如a={1,'abc','13',1};print(a);
(2)set集合的操作
1)union()或用|：求二个集合的并集，其中|直接放在两个集合之间就行。例如a={1,2,3,4};b={2,4,6,8};c=a.union(b);print(c);又例如a={1,2,3,4};b={2,4,6,8};c=a|b;print(c);
2)intersection()或用&：求二个集合的交集，其中&直接放在两个集合之间就行。例如a={1,2,3,4};b={2,4,6,8};c=a.intersection(b);print(c);又例如a={1,2,3,4};b={2,4,6,8};c=a&b;print(c);
3)difference()或—：求二个集合的差集，其中—直接放在两个集合之间就行。这里要注意：差集的集合是有前，后之分的(即A.difference(B)表示A中有但B中没有的元素，B.difference(A)表示B中有但A中没有的元素)。例如a={1,2,3,4};b={2,4,6,8};c=a.difference(b);print(c);d=b.difference(a);print(d);
又例如a={1,2,3,4};b={2,4,6,8};c=a—b;print(c);
4)issubset()或用>或用<=:表示二个集合是否是子集关系，返回的是boolean值。其中A.issubset(B):表示A是否是B的子集？即A的元素是否在B中都存在？B.issubset(A):表示B是否是A的子集？即B的元素是否在A中都存在？如a={1,2,3,4};b={1,2,3,4,5};c=a.issubset(b);print(c);
5)add():向某个set集合中增加值。例如a={1,2,3,4};c=a.add(5);print(c);
6)update():更新某个set集合中的值，有相同就保留一个，没有就会新增进去。例如a={1,2,3,4};c=a.update([4,5]);print(c);
7)remove()：删除某个元素。例如a={1,2,3,4};c=a.remove(1);print(c);
8)pop():弹出操作，这个方法不用带参数，它是先进先出原则(即最左边的元素先被弹出)。例如a={1,2,3,4};c=a.pop();print(c);
十三.赋值机制
(1)指向同一内存空间，可用is直接进行比较是否相同。例如a=1000;b=a; 现在可用id打印出来看下，print(id(a));print(id(b)); 现在用is来比较一下：print(a is b);
(2)另外一种指向同一内存空间的情况。如果创建的2个对象的值是比较小的话，它会共用内存(指向同一块内存的)。例如a=1;b=1; 现在可用id打印出来看下，print(id(a));print(id(b)); 现在用is来比较一下：print(a is b);
(3)创建二个比较大的对象，会指向不同内存空间。例如a=1000;b=1000; 现在可用id打印出来看下，print(id(a));print(id(b)); 现在用is来比较一下：print(a is b);
十四.判断结构
(1)if 逻辑判断条件: ..... 意思是说如果判断条件成立，将做什么
(2)if 逻辑判断条件: ..... elif 逻辑判断条件: ...... else: ......，这里elif是可以写多个的。
注意上面二个结构中的冒号(:)是固定结构来的。逻辑判断条件会有很多的，例如 in，is，<，>，==，<=等等。
例如a=[1,2,3,4];if 1 in a:print('ok');
又例如a={'age':1,name:'2,3,4'};if 'age' in a:print('ok');
又例如a={1,2,3,4};if 3 in a:print('ok');
十五.循环结构
(1)while 逻辑判断条件: …… 这里的逻辑判断就是说如果条件成立就会一直进入循环体中，直到不成立才会跳出循环体，所以一定要考虑会不会跳出循环体以不至于死循环。
例如 a=0
while a<10:
print(a)
a+=1
(2)while后面直接接集合(例如list，dict字典，set)，就表示只要集合中的元素没循环完就不会跳出循环(也就是说它会循环完集合中的所有元素为止)。例如
a=set([1,2,3,4,5])
while a:
a.pop()
print('abc')
(3)for 变量名 in 集合: …… 这里就是说对集合中元素一个一个遍历，每次遍历出来的值赋给变量名。
例如
a=set([1,2,3,4,5])
for name in a:
print(name)
(4)in后面接索引值(集合写在外面，用range随机生成几个索引值<这里可用len(集合名)先计数出集合中有几个出来>，它是从0开始算第1个索引的):例如
a=['1','2','3','4','5']
for i in range(len(a)):
print(a[i])
(5)continue:跳出当前循环，如果循环体的continue后面还有内容，这后面的内容将不再会被执行，直接执行下一循环。
例如
a=[1,2,3,4,5,6]
for i in range(len(a)):
if a[i]%2==0:
print(a[i])
else:
continue
print(a[i])
(6)break:跳出整个循环，循环生命周期结束。
例如
a=[1,2,3,4,5,6]
for i in range(len(a)):
if a[i]%2==0:
print(a[i])
else:
break
print(a[i])
注：continue与break通常是循环中的条件结构语句里加入。
十六.函数定义
(1)定义：def 函数名(): 函数体 或def 函数名(1到多个参数):函数体。这里一定用def开头。
(2)函数体中如果有return 要返回的值 就表示执行这个函数后将返回值给调用方，否则不返回。例如
def add(a,b):
print('ok')
return a+b
(3)用*表示不定个数的参数，例如
def add(a,*args):
for i in args:
b +=i
print(b)
调用代码为 add(1, 2,3,4,5)或add(1, 2)或add(1, 2,3)或add(1, 2,3,4)或add(1, 2,3,4,5)
(4)用**表示不定个数的字典参数(key:value形式)，例如
def add(a,**kwargs):
for k,v in kwargs.items():
print(k,v)
调用代码如add(1,x=2,y=3)
十七.模块与包
(1)jupyter中在开头写上%%writefile 文件名.py ，然后执行后就可以在本地生成一个py文件，当然用idea工具就不用这样(直接新建即可)。
(2)在jupyter运行这个文件用%run 文件名.py
例如 %run a.py
(3)import 指定路径或貝体指定到py文件名 ，这就表示引入貝体包或者貝体的py文件了。
(4)import 指定路径或貝体指定到py文件名 as 别名，这里用as就把貝体内容指定为别名，因为可能貝体名太长了。这样就可用别名.函数名或别名.变量名
(5)from 貝体指定到py文件名 import py中定义的变量名,py中定义的函数名。这样就可直接用变量名与函数名了。而 from 貝体指定到py文件名 import * 就表示py文件中定义的所有东西都被导进来了
十八.异常处理模块
(1)捕捉异常
try:
except Exception:
这样会捕捉到所有异常(因为是用了Exception)
(2)finally后面的不管是否发生异常，它的内容都会执行。例
try:
finally:
又例如
try:
except Exception:
finally:
(3)自定义异常类
用raise关键字
十九.文件操作
不管是读还是写文件，最后都要调用close()方法对文件进行关闭操作，读写文件一般都要捕捉异常处理。
(1)open(路径)：按指定路径打开指定的文件
(2)对打开的文件调用read()方法，把文件中的内容全部读进来
(3)对打开的文件调用readlines()方法，把文件中的内容按一行一行读进来，放入到list集合中。例如
a=open(路径/a.py)
b=a.readlines()
print(type(b))
print(b)
(4)读完文件后还要调close()方法进行关闭操作
例如
a=open('路径/a.py')
b=a.readlines()
print(type(b))
print(b)
a.close()
(5)打开文件(加个'w'参数)后，调用write()来写内容到文件中。这里要注意用'w'模式的话会把原来的内容删除掉，只保存这次打开时写进去的内容。
a=open('路径/a.py','w')
a.write('absfjfdf')
a.write('\n')
a.write('12345')
a.close()
(6)打开文件(加个'a'参数)后，调用write()来写内容到文件中。这里要注意用'a'模式的话会在原来文件后追加内容进去。
(7)读写文件时捕捉异常，并用finally把文件关闭掉，否则容易出现问题。
例如 a=open('a.py','a')
try:
for i in range(10):
a.write('abcdef')
b=10/(i-5)
a.write(i)
print(b)
except Exception:
print('error')
finally:
a.close()
(8)with可代替(7)中捕捉异常的内容，使里面的内容要么正常执行完，要么以异常方式终止。例如
with open('a.py','a') as f:
f.write(123456)
二十.类的基本定义
类是相对面向对象编程来说，把一些对象公共相同的属性，方法写到一个类中。当要调用这些属性或方法时，只要实例化出类的对象先就行。一个类可以实例化出很多对象。
(1)类的定义。一般结构如下
class 类名:
属性
def __init__(self,属性名):
def 普通方法名(self):
对上面结构进行说明：关键字用class；__init__是初始化方法，也叫构造函数，当创建这类实例时，须执行这个构造函数，创建这类实例时要按构造函数传的参数格式构造；self表示本类实例。
(2)hasattr(实例名,'需判断的属性名')：用来判断这个对象中有没有这个属性
(3)getattr(实例名,'属性名')：按这属性名在这个实例中取出值来
(4)setattr(实例名,'属性名','新的属性值')：重新设置属性值。
(5)delattr(实例名,'属性名')：删除属性
二十一.类的属性操作
(1)类的内置属性
1)__doc__:类的帮助文档
2)__model__:类属于那个模块
3)__name__:类名
4)__bases__:类的父类
5)__dict__:类的构成结构
(2)继承
继承是子类继承父类的意思，它是把父类定义好的方法与属性直接拿来用，因为父类是对子类公共方法与属性进行上一层的抽象。例如动物这个父类定义可有吃，睡，说等方法，而子类狗就可直接继承父类这些方法了，同理子类猫也可继承父类这些方法。
1)子类继承父类格式。class 子类名(父类名):
2)子类继承父类后，当创建子类实例时只会调用子类的构造函数，不会去调用父类的构造函数的。实例化子类对象后，子类对象就可直接调用父类的方法与属性了。
3)方法重写。首先子类先继承父类，然后子类可对父类相同的方法进行重写。当子类调用重写后的方法的话就直接自己重写后的方法了，不会调用父类中相同的方法。
二十二.时间操作
(1)先用import导入时间类(time)，这时就可调用里面方法对时间操作了。
(2)操作。
1)localtime()：把时间戳转成能识别的格式。例如 time.localtime(time.time())
2)asctime()：对时间进行格式化，例对1)中调用localtime()后的时间进行格式化。例如print(time.localtime(time.time()))
3)strftime(指定的时间格式,时间):指时间转成指定的格式。例如print(time.strftime('%Y-%m-%d %H:%M:%S,time.localtime()))
4)help():可查看方法等等的用法。例如print(help(time.strftime))