本人学习python时笔记，欢迎各位提问指错

Python基础

1.输入输出

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#输出
a=22;b=33
print("世界和平")
print(a，b)
print('a的值为{},b的值为{}'.format(a,b))
多次print时自动换行    
取消换行使用  end=''   end='\n'表示换行
print(a,end="")
print(in

#输入
a=input('请输入')  #默认保存为字符串

a,b=3,4    #同步赋值
a,b=b,a    #进行交换值

2.变量命名

允许使用大小写字母，数字，下划线，汉字

首字母不能是数字，不能有空格，不能与保留字相同

命名规范：驼峰命名法、帕斯卡命名法，下划线命名

3.数据类型

数字类型：整数，浮点数，复数

对应： 整数，实数，复数

进制. 十六进制0x开头；八进制0o开头；二进制0b开头 输出时自动转为十进制 ↩

浮点数：

123.45 1.2345e2 浮点数只有十进制

e2表示10的二次方 e-2表示10的负二次方

字符串：

用单引号或双引号括起来的一个或多个字符

python
1
2
3
4
5
s="对酒当歌人生几何"
#切片
print(s[1:4]);print(s[-9:-6]);print(s[1])
正向时第一位是0 ； 反向是最后一位是-1
输出时[1:4]输出123字符，不输出4

复数：

python
1
2
3
4
表示:  a+bj
c=a+bj    
c.real  #获取实数部分  a
c.imag  #获取虚数部分  b

数据类型转化

python
1
2
3
int(x)			//转化为整数
float(x)		//转化为浮点数	
str(x)			//转化为字符串

内容为float类型的字符串不能通过int(x)转换

4.帮助函数

python
1
2
3
4
5
6
7
8
9
10
11
12
print(dir(__builtins__))
#输出所有python内置函数     abs 及之后的函数为常用函数
print(help(abs))
#输出 abs 函数的具体功能
print(help('keywords'))
#输出所有关键词
print(help('if'))
#输出 关键词 if 的具体功能
print(dir(a))
#输出变量 a 可使用的所有函数
print(help(a.imag))
#输出 变量a 的imag 的具体功能

type 捕获数据类型

python
1
2
b=type(a)
b 为 <class 'int'>

5.数字运算

x/y x与y之商，浮点数

x//y x与y的整数商，即商的整数部分

x%y x与y的商的余数，又称模运算

x y x的y次幂

二元运算符+ - / // % * 等都可与 = 连用

python
1
2
3
a=12
a +=2           #运算后a=14
#相当于  a = a + 2

abs(x) x的绝对值

divmod（x,y） (x//y , x%y) 输出为二元数组

pow(x,y [,z] ) 中括号表示可选参数 (x**y)%z

pow(x,y) 计算x的y次方

round(x [,ndigits] ) 对x四舍五入，保留ndigits位小数

max(x1 , x2 , … , xn) 取最大值

min(x1 , x2 , … , xn ) 取最小值

6.字符串

单行字符串 用一对 ‘ ‘ 或 “ ” 作为边界

多行字符串 用三对单引号或双引号表示边界

转义字符：

\n 换行
\\ 反斜杠
\‘ 引号
\“ 双引号
\t 制表符，作用是对齐表格的各列，相当于Tab 多个空格

字符串操作

python
1
2
3
4
5
6
name="python"+"是最接近人工智能的编程语言"  
//  +  表示连接
name="python是最接近人工智能的编程语言"*3
//   *  表示重复
"python"in name
//如果“python”是name的子串，返回True，否则False

eval() 解析并执行字符串（相当于把引号去掉）

可以与input结合使用，捕获数字

python
1
2
3
a=eval('1.2+3.4')   #a 为 4.6

a=eval(input('输入数字'))  #a 为 数字

切片

[x:y:z] 从x到y 步长为z

z为-1时逆序输出

字符串处理方法

方法 描述
a.lower() 返回a的副本，全部小写
a.upper() 返回a的副本，全部大写
a.split(sep) 根据sep分隔字符a，分隔后以列表返回
a.count(sub) 返回字符串sub在a中出现的次数
a.replace(old,new) 用new替换a中的old
a.center(width,fillchar) 字符串居中函数，width是总长度fillchar是填充字符
a.strip(chars) 从字符串a中去除在其左侧和右侧chars中列出的字符
a.join(iter) 将变量iter的每一个元素中增加一个a字符串

内置函数

函数 描述 理解
len(x) 返回字符串长度，也可返回其他组合数据元素个数 长度
str（x） 返回任意类型x对应的字符串形式 转为字符串
chr（x） 返回Unicode编码x对应的编码 x为整数
ord（x） 返回单字符对应的Unicode编码 x为单个字符
hex（x） 返回整数x对应十六进制小写字符串
oct(x) 返回整数x对应八进制小写字符串
bin(x) 返回整数x对应二进制小写字符串

格式控制

format

python
1
2
3
4
print("{0:%^20}python".format("这是"))
//大括号称为槽，格式为{参数序号：格式控制标记}
//格式控制标记
//  ：是引导符号    其他标记跟在后面，顺序如下
填充 对齐 宽度
单个字符，不足宽度是填充 <>^ 左/右/居中对齐 槽的输出宽度

默认填充空格，左对齐，适应宽度

格式控制标记不填或不全填，宽度设定小于放置在此的字符串时不起作用

Python结构

1.判断

<小于 >大于 <=小于等于 >=大于等于 ==等于 ！=不等于

与 and 或 or 非 not

2.分支结构

python
1
2
3
#单分支结构
if 条件：
	 语句块
python
1
2
3
4
5
#二分支结构
if 条件：
	语句块1
else：
	语句块2
python
1
2
3
4
5
6
7
8
#多分支结构
if 条件1:
    语句块1
elif 条件2:
    语句块2
 ····
else:
    语句块n

3.遍历循环-for

使用：

for 循环变量 in 遍历结构：

​ 语句块

​ 遍历结构可以是字符串、文件、range()函数或组合数据类型

python
1
2
for c in "github":
	print(c)

  • range() 函数返回一个可迭代对象

    使用： rangea(start,stop,step)

    参数说明： start 计数开始，省略默认为0

    ​ stop 计数结束，返回值不包含stop

    ​ step 步长，默认为1

  • break 跳出当前循环

    脱离循环程序，

  • continue 结束当前当此循环

    跳出循环体下面为执行语句，不跳出循环

扩展模式

for 循环变量 in 循环结构：

​ 语句块1

else：

​ 语句块2

for循环正常结束后执行else语句，如果循环被 break 打断则不能被执行，因此可以判断循环执行情况

4.无限循环-while

python
1
2
3
4
5
6
7
8
9
while 条件：
	语句块
    
#拓展
while 条件：
	语句块
else：
	语句块
#while正常结束后执行else

5.异常处理

python
1
2
3
4
5
try:
    语句块1
except：
	语句块2
#try运行出错执行except

6.函数

基本使用

python
1
2
3
4
//定义函数
def 函数名 (参数列表):
	函数体
    return 返回值

参数传递

python
1
2
3
4
5
6
7
8
9
10
11
def fact(a, b=2):
    print('\n'.join([''.join([(a[(x - y) % len(a)] \
    if ((x * 0.04) ** 2 + (y * 0.1) ** 2 - 1) ** 3 - (x * 0.04) ** b * (y * 0.1) ** 3 \
    <= 0 else ' ') for x in range(-30, 30)]) \
    for y in range(30, -12, -1)]))

#设置参数时可设置默认值，调用时可不传递
#非可参数必须在可选参数后面
fact("python")
#传递参数时可以写入参数名，防止混乱
fact(a="python"，b=2)

变量作用域

局部变量 函数内定义，函数内有效

全局变量 函数之外定义，全局有效，使用 global 声明

组合数据

1.基本

  1. 集合类型：元素集合，无序。集合（set）
  2. 序列类型：元素向量，存在先后关系，通过序号访问。字符串（str）、列表（list）、元组（tuple）
  3. 映射类型：“键-值”数据项组合，键值对。字典（dict）

2.集合类型

与数学中的集合一致，内含元素独一无二自动过滤重复元素，无序，用大括号｛｝表示，没有位置和索引概念，可进行动态增删

python
1
a={11,11,22,33,33,54}

集合运算

符号 逻辑
S&T 交集 S和T中同时包含的元素
S\ T 并集 同时包含S和T中所有元素
S_T 差集 包括在S中但不在T中
S^T 补集 S和T中非共同元素

集合操作函数

set()函数将其他组合数据变为集合类型，也可以生成空的集合变量

python
1
2
n = set()
s = set('集合类型')
函数或方法 描述
S.add(x) 将x增加到S中
S.remove(x) 将x从S中移除
S.clear() 移除S中所有数据项
len(S) 返回S中元素数量
x in S 判断x是否在S中，返回True或False
x not in S 判断x是否不在S中，返回True或False

3.列表类型

列表用中括号表示，没有长度限制，元素类型可以不同，属于序列类型，可以通过 list(x) 函数将集合或者字符串转换成列表类型

不会删除重复元素，有顺序

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
x="列"
s=list("列表类型")
t=list("list")

print(x in s)  #判断x是否在s中
print(x not in s) #判断x是否不在s中
print(s+t) #连接s和t
print(s*3)	#重复3遍
print(s[3])  #索引该位置
print(s[0:3:1])  #步骤切片
print(len(s))	#长度
print(min(s),max(s))	#最大/小值
print(s.index(x))	#s中第一次出现位置
print(s.count(x))	#s中出现x次数


s.append("是")#在最后添加“是”
s.insert(2,x) #在2处增加元素x
s.clear() #删除所有
s.pop(3) #去除3处元素，并删除
s.remove(1) #移除位置1处元素
s.reverse() #将元素反转
s.copy()  #生成新列表，复制s中全部元素

4.元组

与列表类似，使用小括号，创建简单，在括号中添加元素并用逗号分隔即可，使用tuple(x)可转化为元组

元组元素不可被修改，list类型的其余操作可用

5.字典

使用大括号建立：

｛ 键1：值1，键2：值2，……键n：值n ｝

键值对之间没有顺序，且不能重复，性质与集合类似

python
1
2
3
4
5
6
7
8
9
10
11
12
13
d = {"高数"：2,"大物"：3}
d["大英"]=4
len(d)   #长度
min(d)   #键的最小值
max(d)
a=dict()  #定义字典
d.keys()  #字典的键，数据类型为dict_keys，若使用先转换
d.values()   #返回值，与上同
d.items()    #返回键值，与上同
d.get(key,default)  #获取对应的值，没有则返回default
d.pop(key,default)  #获取对应的值并删除
d.popitem()  #获取随机的键值并删除
d.clear()  #删除所有

遍历循环

python
1
2
3
4
for 变量 in 字典名
	语句块
#索引时将键赋值给变量

文件操作

1.txt文件

  1. 文本文件 txt
  2. 二进制文件 图片视频

操作流程打开——操作——关闭

打开文件

变量名 = open(文件路径及文件名，模式)

路径使用 \\ 或 /

模式 描述
r 只读
w 覆盖写，
x 创建写,创建文件
a 追加写
b 二进制文件模式
t 文本文件模式
+ 与r/w/x/a一同使用

变量名.close

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
f=open("G:\\Python\\txt.txt","a")
f=open("G:\\Python\\txt.txt","r+")
print(f.read())
f.write("99999999")
f.close()

#文件读取只有第一次会调用，后面不在生效
#实测a+无法读取文件，r+模式下光标出现在开头一次
read(10)  读取10个字符
readline() 读取第一行，有参数读取该行前n个字符
readlines() 读取所有行，如有参数则读取第n行

seek（0） 改变指针位置，0为开头，1为结尾
write（）向文件写入内容
writelines（）将列表类型全部元素连接起来写入文档中

2.数据维度

  1. 一维数据

    由对等关系的有序无序数据构成

  2. 二维数据

    也称表格数据，采用二维表格方式组织，对应数学中的矩阵

  3. 高维数据

    由键值对类型数据构成，采用对象方式组织，可以多层嵌套

    高维数据在web中常见，是internet组织内容的主要方式，常见有HTML、XML、JSON等具体组织语法结构

    HTML可在网页中查看

    XML Android Studio里

    JSON https://daily.zhihu.com/

    ​ https://news-at.zhihu.com/api/3/stories/latest

一位数据

python 中主要以列表的形式存储

总体思路是采用特殊字符分隔元素，比如空格，逗号，换行符，以及其他特殊分隔符

python
1
2
3
4
ls=['一','二','三']
f.write(",".jion(ls))
join()  将序列中元素以指定字符连接生成新字符串
print(",".jion(ls))

csv文件 逗号分隔值

通用的、相对简单的文件格式，后缀名一般为 .csv

一位数据保存后，各元素间采用逗号分隔（英文逗号），在商业和科学上应用广泛

python
1
2
3
4
5
f=open("12.csv","r")
ls=f.read()
ls_new=ls.split(',')
#通过指定分隔符对字符串进行切片，返回列表
f.close

二维数据

csv文件也可存储二维数据

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ls=[["1","2"],
    ["3",["4"]]]
f=open("12.csv","w")
for row in ls:
    f.write(",".join(row)+"\n")
f.close



f = open("12.csv", "r")
ls = []
for line in f:
    ls.append(line.strip('\n').split(","))

    # a=line.strip('\n')
    # b=a.split(',')
    # ls.append(b) 
f.close

3.Excel文件

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#引入Excel库的xlrd   1.20版本
import xlrd

# 打开刚才我们写入的 test_w.xls 文件
wb = xlrd.open_workbook(r'E:\MATLAB\project\shiyan\12.xlsx')
# 获取并打印 sheet 数量
print( "sheet 数量:", wb.nsheets)
# 获取并打印 sheet 名称
print( "sheet 名称:", wb.sheet_names())
# 根据 sheet 索引获取内容
sh1 = wb.sheet_by_index(0)
# 也可根据 sheet 名称获取内容
sh = wb.sheet_by_name('成绩')
# 获取并打印该 sheet 行数和列数
print( u"sheet %s 共 %d 行 %d 列" % (sh1.name, sh1.nrows, sh1.ncols))
# 获取并打印某个单元格的值
print( "第一行第二列的值为:", sh1.cell_value(0, 1))
# 获取整行或整列的值
rows = sh1.row_values(0) # 获取第一行内容
cols = sh1.col_values(1) # 获取第二列内容
# 打印获取的行列值
 print( "第一行的值为:", rows)
print( "第二列的值为:", cols)
# 获取单元格内容的数据类型
 print( "第二行第一列的值类型为:", sh1.cell(1, 0).ctype)ets()[0]

面向对象

1.概念

  • 面向过程 ——C语言，Fortran
  • 面向对象 ——C++、Java、python

面向对象是相对面向过程而言

面向对象和面向过程都是一种思想

面向过程强调的是功能、行为

面向对象：将功能封装进对象，强调具备了功能的对象

面向对象是基于面向过程的

封装、继承、多态。而面向对象的过程就是找对象、建立对象、使用对象、维护对象的关系的过程。

2.类（class）

具有相同属性和方法的一组对象的描述或定义。

类：是对现实生活中事物的描述。

对象：就是这类事物，实实在在存在的个体。

python
1
2
3
4
5
6
7
8
class Lei():
    """类的说明文档"""
    def __init__(self,传递参数)：
    	self.参数=传递参数
    ……
#类中的函数称为方法


3.类的继承

构造方法

class 子类名（父类名）：
    def __init__(self, 父类全部参数，子类参数):
        super(子类名, self).__init__(父类参数)
        self.参数=子类参数
    def 函数（self）：
        内容

子类需要使用父类参数时必须在init里写入传入参数

使用super行的语句可以继承父类的全部方法

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name))
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name):
        super(Son, self).__init__(name)
        print ("hi")
        self.name =  name
    def getName(self):
        return 'Son '+self.name
 
0if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )

情况一：子类需要自动调用父类的方法：子类不重写init()方法，实例化子类后，会自动调用父类的init()的方法。

情况二：子类不需要自动调用父类的方法：子类重写init()方法，实例化子类后，将不会自动调用父类的init()的方法。

情况三：子类重写init()方法又需要调用父类的方法：使用super关键词：