2021-03-07

一、python基础

1、基本数据类型

1.1 Number（int、float、complex）

x=6;y=8
print('x/y=',x/y) #商
print('x//y',x//y) #整数商
print('x%y=',x%y) #余数，也称模运算
print('x**y=',x**y) #x的y次幂

1.2 String

单引号和双引号可以表示单行字符串，三引号表示多行；用单引号时，双引号可表示为字符的一部分，用双引号时也同理。

1.2.1 转义字符

world!'      #\为续行符
s2='hello \\ w'
s3='It\' a cat! '
s4='It\'s \'cute\' .'
print(s1,s2,s3,s4,sep='\n')

在’ ‘之间定义的字符串之中再出现单引号（或双引号之间再出现双引号）时，解释器会由于无法识别字符串定义的开始和结束位置而报错，故需要用 +’ 来进行转义说明。

1.2.2 字符串切片

[start🔚step] 从start 提取到end ，每step 个字符提取一个。start从0开始索引，end从-1开始。

#s[:-1] 从开始到最后一位，但不包括最后一位
#s[::-1] 倒着取，通过设置步长为-1
s='jfjdvnjfnuriesa,lasfepwkvm'
print(s[0:6:2],s[:-1],s[:],sep='\n')
#s[-5:-1]从后向前索引，最后一位为-1，倒数第二位-2，以此类推
print(s[-5:],s[-5:-1],s[::-1],sep='\n')

jjv
jfjdvnjfnuriesa,lasfepwkv
jfjdvnjfnuriesa,lasfepwkvm
pwkvm
pwkv
mvkwpefsal,aseirunfjnvdjfj

1.2.2 结构化输出

整数输出

%d ——转换为带符号的十进制整数|
%o——转换为带符号的八进制整数
%x、%X——转换为带符号的十六进制整数

浮点数输出
%e——转化为科学计数法表示的6位有效数字的浮点数（e 小写）

eg：%.3e，保留3位小数位，使用科学计数法

%E——转化为科学计数法表示的6位有效数字的浮点数（E 大写）

%f——转化为十进制浮点数，默认6位；%.3f，保留3位小数位

%g——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法

%.3g，保留3位有效数字前提下，使用小数或科学计数法

print('%o'%15,'%d'%15,'%x'%15,sep=',')
print('%f'%1.11111,'%.2f'%1.11111,sep=',')
print('%e'%1.11111,'%.3e'%1.11111,sep=',')
print('%g'%1.1111111,'%.2g'%11.111,'%g'%11.11,'%.3g'%1111.1111111,sep=',')

17,15,f
1.111110,1.11
1.111110e+00,1.111e+00
1.11111,11,11.11,1.11e+03

字符串输出
%s
%10s——右对齐，占位符10位
%-10s——左对齐，占位符10位
%.2s——截取2位字符串
%10.2s——10位占位符，截取两位字符串

print('%s' % 'hello world')  # 字符串输出
print('%20s' % 'hello world')  #右对齐，占位符20位
print('%-20s' % 'hello world')  #对左齐，占位符20位
print('%10.2s' % 'hello world')  #右对齐，截取2字符

hello world
         hello world
hello world         
        he

1.2.3 format()方法

相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’

1.2.3.1位置匹配

print('{} {}'.format('hello','world'))  #不带编号
print('{0} {1}'.format('hello','world'))  #带编号
print('{0} {1} {0}'.format('hello','world'))
print('{a} {b} {c} {a}'.format(a='hello',b='world',c='!'))  #带关键字

hello world
hello world
hello world hello
hello world ! hello

1.2.3.2 格式转换

：+ 字母
‘d’ —— 十进制整数。将数字以10为基数进行输出。
‘b’ —— 二进制。将数字以2为基数进行输出。
‘o’ —— 八进制。将数字以8为基数进行输出。
‘x’ —— 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
‘c’ —— 字符。在打印之前将整数转换成对应的Unicode字符串。
‘e’ —— 幂符号。用科学计数法打印数字。用’e’表示幂。
‘g’ —— 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
‘n’ —— 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。
‘%’ —— 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。

print('{:b}'.format(100)) # ‘：+’ 所转换的类型
print('{0:b},{0:c},{0:b},{0:d},{0:o},{0:x},{0:x},{0:e},{0:g},{0:f},{0:n}'.format(20))

1100100
10100,,10100,20,24,14,14,2.000000e+01,20,20.000000,20

1.2.3.3 复合用法

顺序为：填充>对齐>取的位数>保留小数点

print('{:<s} and {}'.format('hello','world')) #< 左对齐（默认）
print('{:^10s} {:^10s} {:^10s}'.format('hello','and','world')) #> 右对齐、^ 中间对齐,取10位中间对齐
print('{0} is {0:>10.3f}'.format(1.23456))  # 取3位小数，右对齐，取10位
print('{:&^30}'.format('centered'))  # 使用“&”填充)
print('{:0=20}'.format(11))   # “=”只能应用于数字，这种方法可用“>”代替

hello and world
  hello       and       world   
1.23456 is      1.235
&&&&&&&&&&&centered&&&&&&&&&&&
00000000000000000011

百分数

print('{:.2%}'.format(19/21)) #转化为百分数并保留两位小数

90.48%

时间

import datetime
d = datetime.datetime(2021, 3, 12, 14, 5, 58)
print('{:%Y-%M-%D %H:%M:%S}'.format(d))

2021-05-03/12/21 14:05:58

分隔金钱

# print('{:%Y-%M-%D %H:%M:%S}'.format(d))
print('{:,}'.format(123456789))  #，分隔金钱

123,456,789

1.3 List

可包括多个元素，元素类型可不同。

切片与字符串类似

ls=[2,5,8.9,'gifkj',3+4j,['k',3,5],9]
print(ls[:],ls[:-1],ls[:-1],sep='\n')
print(ls[::-1])
print(ls[2:-1],ls[-3:-1],sep='\n')

[2, 5, 8.9, 'gifkj', (3+4j), ['k', 3, 5], 9]
[2, 5, 8.9, 'gifkj', (3+4j), ['k', 3, 5]]
[2, 5, 8.9, 'gifkj', (3+4j), ['k', 3, 5]]
[9, ['k', 3, 5], (3+4j), 'gifkj', 8.9, 5, 2]
[8.9, 'gifkj', (3+4j), ['k', 3, 5]]
[(3+4j), ['k', 3, 5]]

1.4 Tuple

可包括多个元素，元素类型可不同，元组所有元素写在小括号里，元组的元素不能修改。

t=(1,2,6,'kjgkv',8,0,True,5.3,[3,6,'ksa'],(2,3.0,'jio'))
print(t[:],t[::-1],t[:-1],sep='\n')
print(t[-1:])
print(t[3:-1],t[-2:],sep='\n')

(1, 2, 6, 'kjgkv', 8, 0, True, 5.3, [3, 6, 'ksa'], (2, 3.0, 'jio'))
((2, 3.0, 'jio'), [3, 6, 'ksa'], 5.3, True, 0, 8, 'kjgkv', 6, 2, 1)
(1, 2, 6, 'kjgkv', 8, 0, True, 5.3, [3, 6, 'ksa'])
((2, 3.0, 'jio'),)
('kjgkv', 8, 0, True, 5.3, [3, 6, 'ksa'])
([3, 6, 'ksa'], (2, 3.0, 'jio'))

1.5 Set

包括多个元素，元素类型可不同但必须是可哈希对象，但集合各元素无序，不允许有相同值的元素。其作用主要是进行元素的快速检索，以及进行交集、并集等集合运算。

a=set('True')
b={'hello','world'}  #set表示创建一个集合
c={'hello','python'}
d= {'你好'}
print(a,b,c,d,sep='\n')
print(b&c,b.intersection(c),sep='，') #求交集
print(b|c,b.union(c),sep='，') #求并集
print(b-c,b.difference(c),sep='，') #求差集

{'r', 'T', 'e', 'u'}
{'world', 'hello'}
{'python', 'hello'}
{'你好'}
{'hello'}，{'hello'}
{'python', 'world', 'hello'}，{'python', 'world', 'hello'}
{'world'}，{'world'}

1.6 Dictionary

无序的对象集合，是一种映射类型，每一元素是一个键：值 对，键是唯一的，不同元素的键不能相同，且必须是可哈希数据不能是列表、集合、元组、字典。

a={} #创建空字典
b=dict({'a': 1, 'b': 2,'c':3}) #创建字典
print(a,b,sep=',')
print(b['a'])

{},{'a': 1, 'b': 2, 'c': 3}
1

2、分支语句与循环语句

程序的三种结构：顺序、分支、循环。

2.1 分支结构

score=eval(input('请输入成绩：'))
if score<60:
    print('不及格')
elif score<70:
    print('及格')
elif score<80:
    print('中等')
elif score<90:
    print('优良')
else:
    print('优秀')

请输入成绩：90
优秀

2.2 循环结构

ls=['python','C++','PHP','R','Java']
for i in ls:
    print(i)
for k in range(10):
    print(k+1,end=',')

python
C++
PHP
R
Java
1,2,3,4,5,6,7,8,9,10,

两种结构对比

#计算1+2+...+100的值
i=0;sum1=sum2=0
while i<100:
    i +=1
    sum1 +=i
print(sum1)

for j in range(100):
    j=j+1
    sum2=sum2+j
print(sum2)

5050
5050

3、函数

4、类和对象

5、读写文件

5.1 打开和关闭文件

‘r’	以只读方式打开
‘w’	以写方式打开，不能读，文件不存在则创造新的文件；存在则清空原文件
‘a’	以追加方式打开，不能读，在文件已有数据后继续写，文件不存在则创造新的文件
‘b’	以二进制方式打开
‘t’	以文本方式打开
‘+’	以读/写方式打开，可以读/写数据

with open('D:\\python_study\\watermelon_booktest.txt','w') as f:
    pass
print('文件已关闭：',f.closed)

文件已关闭： True

5.2 读写文件

6、异常处理

二、常用第三方库

1、Numpy

生成数组，并获取数组的大小

arr1=np.array([1,2,3,4]) #4行1列
arr2=np.array([[1,2,3],[2,4,6],[8,9,10],[7,8,9]]) #4行3列
arr3=np.array((1,2,3,4,5)) #5行1列
print(arr1,arr2,arr3,sep='\n')
print(arr3.shape)  #shape函数获取数组大小

[1 2 3 4]
[[ 1  2  3]
 [ 2  4  6]
 [ 8  9 10]
 [ 7  8  9]]
[1 2 3 4 5]
(5,)

其他生成方式

a=np.arange(0,1,0.1) #arange(开始，终值，步长)方法不包括终值
print(a)
b=np.linspace(0,1,5) #linspace(开始，终值，元素个数)，默认包含终值
print(b)
c=np.logspace(0,2,5) #与linspace相似，不过创造等比数列，为10**0~10**2(1-100)
print(c)

[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
[0.   0.25 0.5  0.75 1.  ]
[  1.           3.16227766  10.          31.6227766  100.       ]

改变数组维度，有shape和reshape两种方法

arr=np.array([[1,3,6],[2,4,8],[3,6,9],[5,7,8]])
arr.shape=3,4  #用shape函数改变数组维度，但储存位置没变
print(arr)
arr.shape=2,-1 #某轴为-1时，根据元素个数自动计算轴的长度
print(arr)
print(arr.reshape(1,12)) #直接用arr.reshape()来改变

[[1 3 6 2]
 [4 8 3 6]
 [9 5 7 8]]
[[1 3 6 2 4 8]
 [3 6 9 5 7 8]]
[[1 3 6 2 4 8 3 6 9 5 7 8]]

一些重要属性：

• ndim：数组的维度（秩）
• shape：数组的大小，几行几列
• size:数组中元素总个数
• dtype:描述数组中元素的类型

arr=np.array([[1,3,6],[2,4,8],[3,6,9],[5,7,8]])
print(arr.ndim,arr.shape,arr.size,arr.dtype,sep=',')

2,(4, 3),12,int32

矩阵运算：程序简单时可以用matrix类进行矩阵运算，但同时存在ndarry和matrix对象容易搞混。

matrix的一些用法

d=matrix([[1,2,3],[2,3,4]])
e=matrix([[5,3,1],[9,8,7]])
print(np.multiply(d,e)) #对应元素相乘
print(np.sort(e),np.mean(e),sep=',') #排序\计算均值

[[ 5  6  3]
 [18 24 28]]
[[1 3 5]
 [7 8 9]],5.5

numpy的一些用法

f=np.arange(12).reshape(3,4) #始点为0，终点为12
g=np.arange(12,24).reshape(4,3) #始点为12，终点为23
I=np.dot(f,g) #矩阵的乘积，不是对应元素相乘
J=np.linalg.inv([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]]) #矩阵I逆
print(I,J)

[[114 120 126]
 [378 400 422]
 [642 680 718]] [[[-2.    1.  ]
  [ 1.5  -0.5 ]]

 [[-1.25  0.75]
  [ 0.75 -0.25]]]

2、Pandas

Pandas的基本数据结构是Series和DataFrame。Series称为序列，DataFrame产生一个一维数组，产生一个二维数组，其每一列是一个Series。

3、Matplotlib

4、Sklearn