python笔记

一、jupyter中markdown的语法

#一级标题

##二级标题

###三级标题

**加粗**

*倾斜*

无序列表

　　- 文本1

　　- 文本2

　　- 文本3

有序列表

　　1. 文本1

　　2. 文本1

　　3. 文本1

表格

　　|num|amount|volume|

　　|:---|:---:|---:|

　　|1|10|98|

　　|60|12|6|

二、Python基本操作

1、基本输入输出

　　直接输入；print()

2、多行语句

　 方式：使用三引号实现换行

　　print("'多行语句'")

 

3、Python注释

两种方式：

　　1>单行注释：#注释内容

　　2>多行注释：'''注释

                            　　内容''’

 

4、模块的导入

　　使用import关键字

 5、赋值

　　方式：<变量名> = <表达式>

　　变量名只能为字母、数字、下划线的任意组合

　　第一个字符不能是数字

　　变量不能与关键字同名

 

------------------------------------------------------------------------------------------------------

 三、Python中的数据类型

（一）标量类型

（二）数值类型

　　int-------整型

　　float---------浮点型

 

　　运算符

 　　　　1>比较运算

 

 

 　　　　2>赋值运算

 

 

 　　　　3>逻辑运算

 

　　字符串

 

 

 　　常规操作

　　　　字符串的加法

 

 

 

 　　　　查看字符串的长度，用len()方法

 

 

 　　　　字符串索引

 

 

 　　　　切片

　　　　写法：变量名[开始索引:结束索引:步长],左闭右开，默认步长为1

 

 

 　　　　子串计数

 

 

　　　　判断开头结尾

 

 

 

　　　　查找子串

 

 

 

 

 　　　　替换（常用于删除操作）

 

 

 　　　　字符串的分割

 

　　　　转换大小写 

　　　　删除左边空白

 

 　　　　删除右边空白

 

 

 　　　　删除两边空白

 

 

 

 

 

 

 

 

 

    

 函数

1、内置函数

函数是组织好的，可重复使用的，用来实现单一、或相关联功能的代码段；

abs(-10)#绝对值函数
help(abs)#查看abs函数的用法

#求列表中元素最大值
a = [2,-1,0,9,6]
max(a)
min(a)
sum(a)

str(100)#数值转成字符串


int('123')#字符转成整数

常见报错：

1>调用函数的时候，如果传入的参数 不对，会报TypeError的错误，并且Python会明确告诉报错原因，如abs()有且仅有1个参数，但给出了两个

2>如果传入的参数数量是对的，但参数类型不能被函数接受，也会报TypeError的错误，并且给出错误信息：如str是错误的参数类型

 

2、函数的定义与返回

 

函数通常有以下几个特征：

(1)使用def关键词来定义一个函数。

(2)def后面是函数的名称，括号中是函数的参数，不同的参数用,隔开，def foo():的形式是必须要有的，参数可以为空；

(3)使用缩进来划分函数的内容：

(4)docstring 用"""包含的字符串，用来解释函数的用途，可省略；

(5)return 返回特定的值，如果省略，返回None。

 

def abs_my(x):      
    if x>=0:            
        return x      
    else:            
        return -x

abs_my(-100)
abs_my(200)


def add(x,y):
        a = x+y
        return a

add(2,3)
add('ab','cde')        

3、全局变量与局部变量

一个变量在函数里面是局部的，只在函数内部存在，影响不到函数外

 

def add(a,b):
    x = a+b
    return x
 
x = 1
add(1,2)

4、位置参数和关键字参数

 

位置传参，传入的参数按顺序

def func(a,b,c):
    x = (a+b)/c
    return x
func(1,2,3)

关键字传参，传入的参数，按名字对应起来，即使顺序错了也没关系

func(a=1,b=2,c=3)

带默认参数的函数：带默认值的参数必须写在最后

def func(a,b,c=3):
    x = (a+b)/c
    return x
func(1,2)

#定义一个函数，对列表中的元素进行转换：如果为整型，就执行平方，如果为字符串，就将字符串转为大写
L  = ['python',2,78,'abchd']
def func(x):
    if type(x) == int:
        a = (x +1)**2
        return a
    if type(x) == str
        return x.upper()
 
L2 =[]
for i in L:
    L2.append(func(i))
L2

 

匿名函数

Python支持一种被称为匿名的，或lambda函数，它仅由单条语句组成，该语句的结果就是返回值

 

f = lambda x:x+1
f(5)  #结果为6

#使用自定义函数
def func(x):
　　return x+1
func(100)

#匿名函数写多个参数
f2 = lambda a,b,c:a+b+c
f2(1,2,3)  #执行结果为6

#使用自定义函数
def func(a,b,c):
　　return a+b+c
func(1,2,3)

#有默认取值的匿名函数
f3 = lamda x,y=3:x*y
f3(2) #结果为6

 

 filter(function,seqence)：一般过滤筛检序列中的元素

 

list(filter(lambda x:x%3==0,[1,2,3,4,5,6,7]))#将列表中的值进行lambda的计算

map(function,iterable1,iterable2)：一般多个序列使用

 

#计算两个列表中元素的和
x = [1,2,3,4,5]
y = [2,3,4,5,6]
list(map(lambda a,b:a+b,x,y))#直接执行map显示的为一个迭代器，需要转成list

应用

编写一个简易计算器，实现加法、减法、乘法、除法、幂、阶乘、列表元素加和的功能

def cal(x,y,label):
    if label=='加法':
        return x+y
    if label=='减法':
        return x-y
    if label=='乘法':
        return x*y
    if label=='除法':
        if y==0:
            print('输入的被除数不能为0')
        else:
            return x/y
    if label=='幂':
        return x**y
    if label=='阶乘':
        r1 = 1
        r2 = 1
        while x>0:
            r1*=x
            x-=1
        while y>0:
            r2*=y
            y-=1
        return r1,r2
    if label=='列表元素加和':
        c = []
        if len(x)<=len(y):
            for i in range(len(x)):
                c.append(x[i]+y[i])
            for i in range(len(x),len(y)):
                c.append(0+y[i])
        if len(x)>len(y):
            for i in range(len(y)):
                c.append(x[i]+y[i])
            for i in range(len(y),len(x)):
                c.append(x[i]+0)
        return c

 Numpy基础

1、ndarray数组基础

导入

import numpy as np

创建数组

创建数组是进行数组计算的第一步，可以通过numpy库包内的array()函数定义数组实例对象，其参数为Python的序列对象，如果想定义多维数组，则传递多层嵌套的序列。

#创建一维数组
a = np.array([1,2,3])
print(a)#输出[1 2 3]
#创建二维数组
b = np.array([[1,2,3],[2,3,4]])
print(b)#输出[[1 2 3],
           #[2 3 4]]

#存放同类型数据的数组

b = np.array([[1,2,3.],[2,3,4]])

print(b)#输出[[1. 2. 3.],
            #[2. 3. 4.]]

数组属性

查看数组维数使用ndim

b.ndim#输出2

查看数组的形状使用shape，返回(n,m)，其中n为第一维（行数），m为第二维（列数）

b.shape#返回(2,3),b是二维数组，2显示的第一维有两个元素，3显示的第二维有3个元素
a.shape#返回(3,),a是一维数组，3显示的第一维有3个元素，没有第二维

查看元素类型使用dtype，比如numpy.int32、numpy.float64

b.dtype#输出dtype('float64')
a.dtype#输出dtype('int32')

2、特殊数组

Numpy的特殊数组主要有以下三种：

   zero数组：全零数组，元素全为0；

   ones数组：全1数组，元素全为1；

   empty数组：空数组，元素全近似为0

np.zeros((2,5))
#输出array([[0.,0.,0.,0.,0.],
              #[0.,0.,0.,0.,0.]])

np.ones((3,4))
#array([[1., 1., 1., 1.],
 #      [1., 1., 1., 1.],
 #      [1., 1., 1., 1.]])

3、序列数组

arange函数：属于Numpy库，其参数依次为：开始值，结束值，步长。

np.arange(1,10)
#输出array([1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(1,100,10)
#输出array([ 1, 11, 21, 31, 41, 51, 61, 71, 81, 91])

linspace函数创建等差序列数组，其参数依次为：开始值、结束值、元素数量。

np.linspace(0,100,5)
#输出array([  0.,  25.,  50.,  75., 100.])

4、数组索引

Numpy数组的每个元素，每行元素、每列元素都可以用索引访问。注意：索引从0开始

其操作与列表基本相同

a = np.array([[1,2,3],[3,6,9]])
a[0,1]#输出2
a[0,:]#输出array([1, 2, 3])
a[0,0:2]#输出array([1, 2])
a[:,2]#访问第三列,array([3, 9])

5、数组运算

a = np.array([1,2,3])
b = np.array([4,5,6])

      1>加法：

a+b#输出array([5, 7, 9])

     2>减法：

a-b#输出array([-3, -3, -3])

     3>乘法：

a*b#输出array([ 4, 10, 18])

     4>乘方：

a**2#输出array([1, 4, 9])

     5>除法：

a/b#输出array([0.25, 0.4 , 0.5 ])

     6>判断大小，返回bool值

a>=2#输出array([False,  True,  True])

     7>a中最大的元素

a.max()#输出3

     8>a中最小的元素

a.min()#输出1

     9>a的和

a.sum()#输出6

6、数组拷贝

数组的拷贝分为浅拷贝和深拷贝两种：

浅拷贝通过数组变量的复制完成，浅拷贝只拷贝数组的引用，如果对拷贝对象修改，原数组也将修改

深拷贝使用数组对象的copy方法完成，在内存中分开存放，改变拷贝数组，原数组不会改变。

#浅拷贝
a = np.ones((2,3))
b = a
b[1,2] = 9
print(a)
'''[[1. 1. 1.]
 [1. 1. 9.]]'''

#深拷贝
a = np.ones((2,3))
b = a.copy()
b[1,2] = 9
print(a)
'''[[1. 1. 1.]
 [1. 1. 1.]]'''

7、转置

a.T

 

----------------------------------------------

1、快速的元素级数组函数