python内容学习与补充-假期计划

前言

之前的暑假里有学过python，因为当初有了c语言的基础，所以看了某个网课后觉得很膨胀，学的很随性，并且该课程的内容也有限，自己还没有做笔记，于是就有很多东西不清楚或者是不了解。真正做起项目（其实就是作业）的时候经常搞忘东西，现查找花费的时间较多。虽说不一定程序员要对计算机世界中的什么东西都很熟悉，这是不可能的，不会的东西还是要去学习的。但是如果学会了不记下来很快就会忘，想想我光“文件处理”相关的我就反复查了很多遍，写了就忘，写了就忘，满满的泪啊。倒不如自己记下来，一是印象深，二是方便查阅。

于是做了现在这个笔记，因为这个是用来填坑的，所以比较混乱，想到哪写到哪。。。

学习计划

• 数据结构和算法
• 加深对“对象”的理解，学会面向对象编程
• 记录一些常用的操作
• 机器学习相关笔记
• 东西很杂，后续继续补充

自顶向下设计，自底向上执行

数据类型

数据组织的维度

根据数据的关系不同，数据组织可以分为：一维数据、二维数据和高维数据。

• 一维数据，由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中数组的概念。
  • 主要由列表形式表示；
  • 存储方式有多种，总体思路是采用特殊字符分隔各个元素
  • 逗号分割的存储格式叫做CSV格式（Comma-SeparatedValues，即逗号分隔值），它是一种通用的、相对简单的文件格式，在商业和科学上广泛应用，大部分编辑器都支持直接读入或保存文件为CSV格式
• 二维数据，也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格都属于二维数据。
  • 同理也可以使用csv保存数据
• 高维数据，由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。

指数

科学计数法使用字母e或者E作为幂的符号,以10为基数,含义如下:

<a>e<b> = a*10b
>>> a = 10e2
>>> a
1000.0

复数

>>> b = 2 + 4j
>>> b
(2+4j)
>>> type(b)
<class 'complex'>
>>> print('the real part of b is: {}, complex part is {}'.format(b.real, b.imag))
the real part of b is: 2.0, complex part is 4.0

数值运算操作符

上标所有二元运算操作符(+、-、*、/、//、%、**)都可以与等号(=)相连,形成增强赋值操作符(+=、-=、*=、/=、//=、%=、**=)。用op表示这些二元运算操作符,增强赋值操作符的用法如下:

x op= y 等价于 x = x op y
>>> x = 9
>>> y = 3
>>> x //= y
>>> x
3

数值运算可能改变结果的数据类型,类型的改变与运算符有关,有如下基本规则:

• 整数和浮点数混合运算,输出结果是浮点数;
• 整数之间运算,产生结果类型与操作符相关,/运算的结果是浮点数;
• 整数或浮点数与复数运算,输出结果是复数。

数值运算函数

Python解释器提供了一些内置函数,在这些内置函数之中,有6个函数与数值运算相关:

数据结构

序列类型操作

• 列表，字符串和元组是有序容器
• 字典，集合是无序容器
  列表的每一项可以有不同的属性

first = [1, 2, 3, 4]
second = [5, 6, 7, 8]

1. 索引 [ ]

first[1]
Out[5]: 2

2. 连接 +

first + second
Out[4]: [1, 2, 3, 4, 5, 6, 7, 8]

3. 重复 *

first * 2
Out[8]: [1, 2, 3, 4, 1, 2, 3, 4]

4. 是否在其中 in

4 in first
Out[9]: True
2 in second
Out[10]: False

5. 长度 len

len(second*2)
Out[14]: 8

7. 切片 [ : ]

double = first *2 
double[1:5]
Out[18]: [2, 3, 4, 1]
trible = second * 3
trible[2:9:2]
Out[20]: [7, 5, 7, 5]

列表

值得注意的是，切片的范围是‘左闭右开’，即包括左边的下界，不包括右边的上界。
python里面的列表数据结构还有很多骚操作，值得慢慢补充

但是要注意，如果使用了这些方法，就会对原列表进行修改。如果想修改且不对原列表造成改变，可以将列表复制后再处理，见博客中的方法。

还有一个python中的与list相关的常用功能那就是range。range 产生了一个有顺序的对象,这个
对象可以表示一个序列。在使用list里的功能时,可以将range对象里的值视为一个列表。同样的，range的范围也是左闭右开。下面是关于它的阐释:

range(1,11)
Out[29]: range(1, 11)
list(range(1, 11, 2))
Out[30]: [1, 3, 5, 7, 9]
list(range(10, -3, -2))
Out[31]: [10, 8, 6, 4, 2, 0, -2]

字符串

‘\’是转义符
字符串是可以储存零个或多个字母,数字,或其他符号的有序容器。我们称字母,数字和其他的符号为字符。字符串的值用引号(单引号和双引号都可以,但不能混用)与标识符区分。

作为一个序列，列表中所述的1～7操作在字符串都可以执行，但是除了这些之外，还有些字符串独特的方法：

其中split的使用较多，用于将字符串中的特定文本转换为一个分割符，进而可以将字符串分块转换为列表。

string1 + ' ' + string1
Out[39]: 'romantic in program romantic in program'
(string1 + ' ' + string1).split(' ')
Out[40]: ['romantic', 'in', 'program', 'romantic', 'in', 'program']
>>> a = '/home/born/Data/darknet/cfg'.split('/')
>>> print(a)
['', 'home', 'born', 'Data', 'darknet', 'cfg']
>>> '/'.join(a)
'/home/born/Data/darknet/cfg'

• 字符串和列表之间最大的区别就是列表可以被修改而字符串不能。这被称作可变性。列表是 可变的,字符串是不可变的。比如,你可以通过赋值和索引改变一个列表中的元素,而对于 字符串这种操作是不允许的。
• str.join(iter)中iter是一个具备迭代性质的变量,该方法将str字符串插入iter变量的元素之间,形成新的字符串。
• str.strip(chars)从字符串str中去掉在其左侧和右侧chars中列出的字符。chars是一个字符串,其中出现的每个字符都会被去掉。

元组

元组 tuple 和列表 list 类似,也是异质数据序列容器,区别是,tuple 不可改变其中数据,就像字符串。元表不可被修改。元表表示为用圆括号括起的,用逗号隔开的一系列值。当然,作为一个序列,它也适用于上述的关于序列的1～7运算符。

集合类型

集合

• 集合中的元素必须是不可变的固定数据类型，比如元组，字符串，整数，浮点数，而列表和字典属于可变数据类型，就不能作为元素出现
• 由于其不可重复性，所以可以用于去重

>>> a = ['aaa', 'bbb', 'aaa']
>>> set(a)
{'bbb', 'aaa'}

• 集合是 0 个或多个数据的无序散列容器。集合不允许出现重复元素,表示为花括号括起的、用逗号隔开的一系列值。空的集合表示为 set()。集合是异质的,并且集合是可变的。例如:

>>> {3,6,"cat",4.5,False}
{False, 4.5, 3, 6, 'cat'}

映射类型

字典相关操作

字典是由许多对相互之间有联系的元素组成的, 每对都包含一个键(key)和一个值(value)。这种元素对被称为键值对,一般记作键:值(key:value)。字典的表示方法是,大括号内若干对键值对排列在一起,它们之间用逗号隔开。

• 字典可以通过索引进行修改值和赋值，包括对原本不存在的键值对
• 可以使用dict()生成一个新的字典
• items方法返回的使一个特殊的数据类型叫dict_items

get之前的元素是字典中的一个键，对于get方法的举例：

>>>d.get('201804','不存在')
'不存在'

同理，上面的default都是一个默认的返回值

输入输出

输入

a_string = input("please input whatever you want to input")
please input whatever you want to input>? is this a string?
a_string
Out[3]: 'is this a string?'
a_string = input("please input whatever you want to input")
please input whatever you want to input>? 1234
a_string
Out[5]: '1234'
float(a_string)
Out[6]: 1234.0

文件读取

• 文件类型有两种：文本文件,二进制文件，两种类型最主要的区别是否有统一的字符编码。
• 采用文本方式读入文件，文件经过编码形成字符串，打印出有含义的字符；采用二进制方式打开文件，文件被解析为字节流。
  
• 文件打开后，对文件的读写有一个读取指针，当从文件中读入内容后，读取指针将向前进，再次读取的内容将从指针的新位置开始。
• f.seek()方法能够移动读取指针的位置，f.seek(0)将读取指针移动到文件开头，f.seek(2)将读取指针移动到文件结尾。

输出：

使用print，通过修改其参数设置可以改变输出时的格式。print默认使用空格分隔，可以通过设置sep参数改为其他的分隔符,可以修改end参数改变打印末端的格式。当然也可以使用‘+’进行字符串拼接后输出

print('hello','world')
hello world
print('hello','world',sep=''，end='&&')
helloworld&&
print('hello'+'world')
helloworld

如果想让程序有着格式化输出，可以通过在语句中放占位符实现：

print("%s is %d years old." % (aName, age))

% 是字符串运算符,被称为格式操作符
% 的左边是模版或者格式字符串,右边则是一个容器,其中包含了替换格式字符串的变量值。右边容器中的变量的个数必须和左边字符串中的占位符的数目一致,在用变量值替换占位符的过程中,从左到右依次读取变量,按顺序替代占位符的位置。%s显示了这将会是一个字符串填充到这个位置。

字母	输出格式
d	整型
u	无符号整型
f	浮点型
e	浮点型，有指数
c	单个字符
s	字符串
%	用于打印%这个符号

还可以对打印的格式进行进一步修饰：

rows = 1440
name = 'food'
print('the %s has %.2f rows' % (name, rows))
the food has 1440.00 rows
# 通过元祖进行索引
returnvalue = ('trip','goals')
returnvalue
Out[15]: ('trip', 'goals')
print("%s, %s" % returnvalue)
trip, goals
# 通过字典进行索引
itemdict = {"item":"banana","cost":24}
print("The %(item)s costs %(cost)7.1f cents"%itemdict)
The banana costs    24.0 cents

注意%前不要手贱打个逗号，不要忘记括号括起来右边部分。

写入文件

• 使用f.write(s)时，要显式的使用\n写入文本进行分行，如果不进行分行，每次写入的字符串会被连接起来。

控制结构

循环结构

for（遍历循环）

• for可以和很多的python序列容器一起用。因为只要这个容器是一个序列的容器，那么for就可以以你想要的方式、顺序遍历其中的元素。
• for语句的循环执行次数是根据遍历结构中元素个数确定的。
• 使用range()函数,可以指定语句块的循环次数
• 如果是如下结构：

for <循环变量> in <遍历结构>:
	<语句块1>
else:
	<语句块2>

当for循环正常执行之后,程序会继续执行else语句中内容。else语句只在循环正常执行之后才执行并结束,因此,可以在<语句块2>中放置判断循环执行情况的语句。

while（无线循环）

• 条件为真继续执行，为假退出循环.
• 同理，while也可以加else

循环控制

continue跳出当次循环，即一步到本次循环末尾，但是不跳出
break退出当前循环，进入for或者while外面的下一个语句

分支结构

if-else（二分支）-elif（多分支）

if-else为判断语句，条件为真进行一个操作，为假进行另一个操作，可以使用elif代替嵌套，相当于在上一个if没成立的基础之上进行一个操作

异常处理

try-except

In[22]: try:
   ...:     a_number = int(input('please input a integer'))
   ...: except:
   ...:     print('opps, bad input')
   
please input a integer>? 12.4
opps, bad input	

try的作用是截获python解释器给你发回的错误信息，换成自己在except后写的错误提示信息打印出来

raise

当我们想在程序中加入一些’帮助日后处理程序输入类型问题‘的时候，可以自己对所需的数据类型或者一些条件进行界定，将其表示为一个判断语句，如果输入符合我的想法，那么就继续执行万事大吉，如果不符合我当初的思考，那就会打印一个当初用于防范这种错误的提示信息，进而帮助修改bug

>>> if anumber < 0:
...
 raise RuntimeError("You can't use a negative number")
... else:
...
 print(math.sqrt(anumber))
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
RuntimeError: You can't use a negative number

基本函数（内置）

保留字

eval()

eval(<字符串>)函数是Python语言中一个十分重要的函数,它能够以Python表达式的方式解析并执行字符串,将返回结果输出

>>> eval('print(a)')
9 / 3

eval()函数经常和input()函数一起使用（因为input得到的是字符串）,用来获取用户输入的数字,使用方式如下:

<变量> = eval(input(<提示性文字>))
>>> a = eval(input('please input a number'))
please input a number4
>>> a
4

input()

获得用户输入之前,input()函数可以包含一些提示性文字

<变量> = input(<提示性文字>)

print()

print(<输出字符串模板>.format(<变量1>, <变量2>,..., <变量n>))
>>> a, b = 1453, 453
>>> print('a = {}, b = {}'.format(a, b))
a = 1453, b = 453
print(<待输出内容>, end="<增加的输出结尾>")
>>> print(a, end='###')
1453###>>>                  ##注意原本是回车结尾的，但是换了之后失去了换行效果

format()

<模板字符串>.format(<逗号分隔的参数>)
>>>s = "等级考试"
>>>"{:25}".format(s)
 #左对齐,默认
'等级考试            '
>>>"{:^25}".format(s)
 #居中对齐
'     等级考试       '
>>>"{:>25}".format(s)
 #右对齐
'            等级考试'
>>>"{:*^25}".format(s)
 #居中对齐且填充*号
'**********等级考试***********'
>>>"{:+^25}".format(s)
 #居中对齐且填充+号
'++++++++++等级考试+++++++++++'
>>>"{:十^25}".format(s)
 #居中对齐且填充汉字“十”
'十十十十十十十十十十等级考试十十十十十十十十十十十'
>>>"{:^1}".format(s)
 #z指定宽度为1,不足变量s的宽度
'等级考试'
>>>"{:.2f}".format(12345.67890)
'12345.68'
>>>"{:>25.3f}".format(12345.67890)
'                 12345.679'
>>>"{:.5}".format("全国计算机等级考试")
'全国计算机'

面向对象

在Python 里，和很多其他面向对象的编程语言一样，我们定义“类”（class）去描述数据的外观（状态）和功能（行为）。“类”类似于抽象数据类型，“类”的用户只能看到数据项的状态和行为。数据项在面向对象的范式里被称为对象（objects）。对象是类的一个实例。

目前我对于类（class） 的理解是这样的：
一个类就像游戏中的一个人物模型，在开局的时候，所有玩家都有一个初始的角色供我们捏脸，我们每个人可以调整的选项都是一样的，比如我们都只能对人物的鼻子，眼睛和嘴巴进行修改，对于游戏未给我们开放的属性，比如手指的长短，我们都一样，都无法修改。而一个类就像这个初始模型，给玩家提供了一堆选项进行调整。一旦我们捏好了一个人物，即确定了每一项的属性，并且保存过后，这个类就创建了一个基于该类的全新的人物（实例），这个新人物就是所谓的“对象”。
在python中我们通过提供一个名字和一个方法来定义一个类（类似构造函数）。
构造一个类，第一步需要有有个构造函数，其定义了数据对象的创建方式，python中构造函数的方法为__init__。其参数列表的第一项一定为self参数，可以用来作为参考返回对象本身。但是在调用的时候永远都不需要显式的给出实际参数。
如果想要定义一个分数对象，即该对象具有分子和分母两个属性，可以这么定义：

class Fraction:
	def __init__(self, top, bottom):
		self.num = top
		self.den = bottom

.myList.append(False) 可以读作“使对象myList去执行append方法函数并给它一个值False