Python简介

Python：人生苦短，我用Python效率高，易上手。
Python的应用：可以做一些机器学习，深度学习，计算机视觉和自然语言处理应用广泛，比较热门。
Python的历史：创始人荷兰人吉多.范罗苏姆开发的一个脚本解释程序，基于C语言实现的实现了完整的垃圾回收机制。

初识Python

print("hello world !")
就会输出
hello world !
还可以执行
import this
去查看Python的的设计原则
比如有优美胜于丑陋
明了胜于晦涩
简介胜于复杂
等等

Python数值分析

初识变量的赋值

python中不需要指定数据的类型
所以直接变量名 = 变量的格式就是对的
比如
a = 8;

查看数据的类型

可以通过type（变量名）来实现
例如

 a= 4
 type(a)

输出为int
bool类型的值同样有两个true和false用于判断表达式如
3>8
则输出的值为false

类型转换

li = 1.5
type(li)#输出float 
jia = int (li)#此时的值为1 
type（jia）#这个的输出为int
cheng = float(jia)
type(cheng)#输出为float#值为1，只不过它是float可以发现数值型的数据可以在float，int，double之间
转换但是可能会出现数值的丢失
接下来我们转向与String的类型转换
li = '123'
type(li)#输出毫无疑问是String类型的
float（li）#则输出123.0
 #####那么如果字符串的内容不能往数值型的转换的话，那么他就会报错
比如
li = 'li'
type(li)
float(li)
但是当数值型的变量的话往字符串转换完全没有任何问题

介绍一下运算符的运算顺序

*()
* [**]
* */
* +-

运用python去对数据做基本操作

基本操作 含义 实例
round() 四舍五入 round（15.4）
abs() 取绝对值 abs(1.5)
min() 取最小值 min(1,2,3,4,5)
e 科学计数法 1.3e5
字符串的使用 
li='hello world'
print (li)#输出hello world
#如果执行加法操作
jia=li+python
print(jia)
#那么就会输出hello world python
jia = jia *3
print (jia)
#则会输出hello world pythonhello world pythonhello world python
#可以看出来当执行乘法操作的时候就会将字符串做重复的操作

字符串的使用之后的基本操作

li = '1 2 3 4 5 6'
li.split()
#则会输出['1','2','3','4','5','6']
#但是当如下
li= '1,2,3,4,5'
#就不可以进行切分操作了，那么切分操作如何进行呢如下
li = li.split(',')
print (li)
#则会输出['1','2','3','4','5']
jia=''
jia.join(li)
#则输出为'1 2 3 4 5'
li = 'hello python!'
li.relace('python','world')#输出为hello world
li = li.upper()#将字符串的内容全部大写
li.lower()#将字符串中的内容小写
li = '   hello world !       '
li = li.strip()#输出为hello world，去掉了空格
去空格的话有strip函数也有lstrip函数同时也有rstrip函数
'{} {} {}'.format('li','jia',cheng')
#就会输出lijiacheng我的理解是这个操作可以使字符串的使用更加灵活，可以在使用的过程中去使用它的值
#同时也可以使用索引
'{2} {1} {0}'.format('li','jia',cheng')
#则会输出chengjiali
'{li} {jia} {cheng}'.format(li = 5,jia = 2,cheng = 0)
#则会输出520
#除此之外，还有一个古老的方式
#比如
li='lijiacheng'
a=123.0
b= 456
result = '%s %f %d' %(li,a,b)
#则会输出lijiacheng123.000000 456
列表结构 
li = []
type(li)#输出为list
li = [1,2,3,4]
print (li)
#则会输出[1,2,3,4]
li  = ['1','2','3','4']
print(li)
#则会输出['1','2','3','4']
#到目前为止，list结构中的数据类型应该是一样的，但是如果出现了不一样的会怎么样呢
li =[12 ,'dff']
print(li)
#则会输出[12 ,'dff']
#可见他并不会报错在list结构中可以存放任何类型的数据
#这里有一个注意的点
#如果定义的时候需要声明的话，就必须要如下
li= list([lijia])
#小括号中必须有一个中括号否则会报错

list基本操作

操作 示例 注意
len（） len（li） 求list表中的长度
+ 若ab分别是一个列表执行a+b 新表是ab两个表的组合
* 若a是一个列表执行a*2 将a列表的元素重复两次
del[0] a=[1,2,2,2,3]del[0] a=[2,2,2,3]
del[3:] a=[1,2,2,2,3]del[3:] a=[1,2,2]
3 in a a=[1,2,2,2,3]3 in a true

list核心操作

a= [1,2,[3,4]] a[2]
则会输出[3,4]
a[2][1]
则会输出4
li= ['apple','banana','apple','banana','banana','apple','apple']

函数 操作 注意点
count（） li.count('apple') 输出结果为4
index（） li.index('apple') 输出结果为0
append（） li.append('apple') 插入一个元素
insert（） li.insert(2，'apple') 插到相应的位置
remove（） li.remove('apple') 删除相应元素
pop（） li.pop('apple') 出栈并且删除
sort（） li.sort() sort直接排但是sorted()这个就可以不改变原来的结构
reverse（） li.reverse('apple') 反转列表 

li = 'lijiacheng'
li[0]#输出l
li[-1]
#输出g
#这里能注意的就是不能出现数组下标越界从前开始是从零开始从后开始是从1开始

切片

表示从哪到哪
它是一个左闭右开的区间

li[0:2]#输出li
li[2:]#输出jiacheng表示从索引为2的开始后边全要
li[:2]#输出li表示从第一个开始到索引为2的结束还不包括索引为2的
li[]#取全部
li[::2]#每隔两个取一个
字典结构 
构造方式一
li = {}
type(li)#输出dict字典类型的
构造方式二
li= dict()
type(li)

字典的结构操作

key-value键值是唯一的

li['first'] = 123
li['python']=456
print(li)
{'first':123,'python':456}
li['python']#456
li['python']=789#更新
li = {'li':1,'jia' = 2,'cheng' = 3}
print (li)
{'li':1,'jia' = 2,'cheng' = 3}#字典中的key- value没有顺序

字典的核心操作

li = [1,2,3]
lidic={}
li['jiacheng']=li
li['jii']=2
print(li)#输出的结果为{'jiacheng':[1,2,3],'jii':2}
可以看出来这个字典的值得元素可以是列表
learn={}
learn1 = {'li':123,'jia':456}
learn2 = {'li1':789,'jia1':741}
learn['test1']=learn1
learn['test2']=learn2
print(learn)
#输出的结果为{'test1'{'li':123,'jia':456},'test2'{'li1':789,'jia1':741}}
可以看出来字典中也可以有字典
还有一种方式
li = dict([('li',123),('jia',456)])
print(li)#输出结果为{'li':123,'jia':456}
li.get('li')
li['li']
li.get('meiyou','meiyoua')#这个操作的意思是当在字典中查找键值时发现没有就返回get参数里的第二个参数
li.pop['li']#此时字典li的内容为{'jia':456}
del li['jia']
learn = {'li':123,'jia':456}
learn1 = {'li':456,'python':888}
li.update(learn1)
#输出结果为{'li':456,'jia':456,'python':888}
li.keys()
#dict_keys(['li','jia','python'])
li.values()
li.items()
#dict_items([('li':456),('jia':456),('python':888)])
集合

会保留唯一存在的元素

learn = [123,456,123,789]
learn = set(learn)
learn
#{123,456,789}
learn = set()
type(learn)#输出为set
learn = set([123,123,123,456,456,789])
learn#输出为{123,456,789}
learn = {1 ,1,2,3,4}
learn
#输出为{1,2,3,4}

集合的操作

a= {1,2,3,4}
b = {1,2,3,4,5}
a.union(b)#输出为{1,2,3,4,5}
a.intersection(b)
输出为{1,2,3,4}
a.dirrerenrt(b)
#输出为{5}
a = {1,2,3,4,5,6}
b = {2,3,4}
b.issubset(a)
输出True
b<=a
输出True
a={1,2,3,4}
a.add(5)
{1,2,3,4,5}
a.update([4,5,6])
{1,2,3,4,5,6}
a.remove(1);
{2,3,4,5,6}
a.pop()
{3,4,5,6}
赋值机制 
learn = 1
study= learn
id(learn)
id(study)
两个ID的值是一个值
learn is study
得出的结果是true
study= 000
learn is study
得出的结果是false
learn = 1000
study= 10000
id(learn)
id(study)
两个ID的值不是一个值
learn = 1
study= 1
id(learn)
id(study)
两个ID的值是同一个值

总结：这个赋值机制呢当两个变量是一个较大的数时，内存空间是不同的，但是当两个树是比较小的话分配给两个数的内存地址是一个相同的地址

判断结构 
if- else示例一
learn =100
if learn>50:
    print('OK')
print('test')
#输出的结果为OKtest
if- else示例二
learn= 100
if learn >200:
    print('200')
elif learn<100
    print('100')
else:
    print('100-200')
learn =[123,456,789]
if 123 in learn
    print('ok')
#输出结果为ok
learn= ['li':123,'jia':456]
if li in learn
    print('ok')

注意这里的缩进，if下边的语句要加四个空格

循环结构 
learn = 0
while learn< 10:
    print(learn)
    learn+=1
learns = set(['li','jia','a'])
while learns:
    learn=learns.pop()
    print(learn)
#输出为li jia a
for name in learns:
    print(name)
#输出为li jia a
learn =100
for i in range(10):
    print(i)
#输出0 1 2 3 4 5 6 7 8 9
for i in range(len(learns))
    print(learn[i])
#遍历列表的所有元素
continue是跳过本次循环
break是结束循环
learn = [10,11,12,13,14,15]
for i in learn:
    if i%2 ==0:
        print (i)
    else:
    continue
    print(i)
#输出的结果是101012121414
#对比如下
learn = [10,11,12,13,14,15]
for i in learn:
    if i%2 ==0:
        print (i)
    else:
    break
    print(i)
#输出的结果是1010
函数的定义 
a = 10
def print_value():
   print ('a=',a)
print_value()
#输出a=10
def add_ab(a,b):
    print (a+b)
add_ab(3,5)
#输出8