python回顾/学习笔记--基础

python回顾/学习笔记–基础

#Python从零开始系列连载
https://ask.hellobi.com/blog/wangdawei

1.安装环境(anaconda 环境变量)

2.jupyter的常用操作

3/4.Python的基本数据类型
变量
数字（int float bool complex）
type()
isinstance()
进制（二0b 八0o 十六0x） 交互模式运行时会自动转为十进制

浮点数只能以十进制方式书写，也就是不加前缀
（只是比较两个值是否相等，233和233.0可以认为相等，只是精度保留不一样）

复数  .real  实部   .imag  虚部

字符串
''表示空字符串（空字符串就是字符串里没有内容）
单双三引号
注释（单行  多行 ） #
转义   \\  \b  \n  \t 
字符不转义  r""   \\t
操作方法：len()  字符串中的空格也是占长度的，空串：""/'' 长度是零
		 自动接连

		 索引（正向0开始 0 -- m-1  反向-1开始  -m -- -1）

		 切片 开始  结束（不包含） 步长    复制 string(::)  反序string(::-1)
		 索引越界会报错   切片越界不会报错

5/6.运算符和表达式
变量赋值时同时完成定义（区别先定义后赋值）

del 删除

python内存自动回收机制

转换变量类型  int()  float()  str()
	2.33e-4指的是2.33 x e^-4
	int（）强制转换类型时候是扔掉小数点之后的数字，而不是四舍五入
算术运算符
	+ - * / // % **
	隐式类型转换   转换的规则是：低等类型向高等类型转换  等级从低到高是：bool<int<float<complex

	在算术运算时，True代表1，False代表0

	abs(x) 绝对值  complex()建复数  pow(x,y)
	divmod(a,b)  函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
	range() 生产序列
	round() 四舍五入
	sum()
	oct() hex() chr() bin() bool()

    import math
    math.floor()方法是返回小于等于x的最大整数   
    math.ceil() 方法是返回大于等于x的最小整数
	sqrt（x）返回平方根
	exp（x）返回以e为底的指数
	log（x）对数操作
	π 和 e   math.pi  math.e

	from math import *

输入  输出
input()   获得的是是字符串类型数据
print()  sep 参数  分隔符
格式化字符串
%s %d  %f
格式化操作符辅助指令

符号                    作用
-             用做左对齐
+            在正数前面显示加号( + )
#            在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于
              用的是'x'还是'X')
0            显示的数字前面填充‘0’而不是默认的空格
m          m 是显示的总宽度
%m.nf    m指的是输出总宽度，小数点之后保留n位（四舍五入保存），如果总宽度超过m，按照实际显示

str.format()  通过{}来代替%

赋值运算     变量 = 表达式
关系运算符  <  >  <=  >= ==  !=  
			is 比较两个引用是否指向了同一个对象（引用比较） 
			not is


Python中的对象包含三要素：id、type、value
其中id用来唯一标识一个对象，即在内存开辟了一块空间暂时存放这个变量
type标识对象的类型，如之前说过的str，int，float等
value是对象的值
is判断的是a对象是否就是b对象，是通过id来判断的
==判断的是a对象的值是否和b对象的值相等，是通过value来判断的

字符串也可以比较大小  规则是：按照英文字母的排序进行比较
常用字符大小关系是：
    空字符串<空格<'0'~'9'<'A'~'Z'<'a'~'z<汉字
Python中比较浮点数是否相等机制是他们的差距是否小于一个极小的值来判断.所以是精度问题

逻辑运算符 与 或 非
	and：逻辑‘与’运算符，只有当and两边都是真，结果才是真
	or：逻辑‘或’运算符，只要当or一边的是真的，结果就是真
	not：逻辑非运算符，反转逻辑值

表达式
运算符优先级  lambda 最低  or  and  not  in   not in is  not is
			 比较
			 算术
			 正负
			 ...

7/8.Python程序的基本控制流程
复合赋值语句 python中也支持运算操作和赋值操作结合的操作（官方称为复合赋值）
序列赋值
age_1,age_2 = age_2,age_1这种操作是Python独有的

calendar日历模块

顺序结构

分支结构  
if语句
if-else 语句
if-elif-else语句
在设置判断时候要构思好用户可能输入的特殊值

分支语句嵌套


循环结构
while语句 注意循环条件  死循环

for 循环 
for 循环变量 in 对象：
	循环语句 
循环语句嵌套  （九九乘法表）

for i in range(1,10):
for j in range(1,i+1):
    print('{}*{}={} '.format(i,j,i*j),end="")
print("\n")

break  结束当前循环
continue  跳出本次循环，进入下一轮

9/10. 数据类型 list
[] 数据逗号隔开，可以类型相同，可以不同，可以嵌套列表
基本操作：
索引 0开始 负向索引 -1开始
列表相加 +
列表复制 *
len()
for 循环
检查是否存在 in not in
del 删除 del list1[i]
max() min() 同类型比较

切片  list[起始索引：终止索引（不包含）：步长间隔]
	  特殊切片   省略前面/后面    列表逆序 list[::-1]
	  l[:]   复制 id不同，指向内存中不同位置

列表可变，内容可以修改

方法：
l.append()
l.count()
l.extend(seq)  末尾追加序列   extend添加单个元素和append很像，但他可以一次添加更多元素，元素可以是列表
l.index() 查找位置  找不到就报错
l.insert(index,obj) 插入、
l.pop()  pop是删除指定索引位置的元素，是根据索引删除，remove是根据要删除的对象从左至右进行查找，删除第一个匹配的元素
l.remove() 移除第一个匹配项
l.reveese() 反向
l.sort()排序   默认升序   reveese=True  降序
list.clear() 清空   clear()方法相当于del list[:]
list.copy() 注意：修改List不会影响复制后的新列表，
	修改List中的对象，会影响复制后新列表 
	（改列表不会互相影响，但是修改列表里面的对象会影响到对方列表里面对象）


del 删除一个   删除一段（切片） 删除全部

s.index(x)：返回字符串中出现x的最左端的索引值，如果不在则抛出valueError异常
s.find(x) ：返回字符串中出现x的最左端字符的索引值，如果不在则返回-1


列表推导式/生成式   [表达式 for i in 序列]  
[m+n for m in range(1,5) if m%2==0 for n in range(6,10) if n%3==0]
[8, 11, 10, 13]

11/12. 数据类型 tuple
元组是不可改变的，创建后就不能做任何修改操作了
元组包含了列表，所以元组允许嵌套
而且元组包含了可变类型（因为列表是可变的数据类型：我们能对列表值修改，所以说列表是可变类型）
t=()
t=(1,) 单个元素时，记得加逗号
1.索引

2.切片

3.连接

4.复制

5.对内部元素循环

6.查找元组中是否有某元素

7.删除元组

8.返回元组中最大值和最小值

len(t)

除此之外，在列表可行的 pop() append  extend insert  都在元组中不可用

列表和元组 互相转化   list()  tuple()
[(m,n) for m in "abcd" for n in "abcd" if m!=n]

元组解包   将等号右侧的元组中的元素按顺序依次赋值给等号左边的变量，一一对应

元组在某些方面有优势的：
	1.元组的运算速度比列表快，如果你经常要遍历一个序列，且不需要修改内容，用元组比列表好
	2.元组相当于给数据加了保护（不可修改），有些场合需要这种不可修改的内容

13/14. 数据类型 dict dictionary
{键1：值1，键2,：值2}
键必须是唯一的，必须是不可变的，如字符串，数字，元组
值可以是任何数据类型

d={}
d=dict()

d=dict(s=1,t=2) 这种创建  键只能为字符串类型，并且创建的时候字符串不用加引号，
						 不能创建键为数值型的字典

和列表元组的索引相似，以以下形式访问键对应的值：  字典名[键]  如果查找的键不在字典里，会报错

如果不确定，可以先做个检查，查查字典里是否有某个键：  键  in  字典

添加、删除、更新修改 字典中的键值对

操作方法： dict.keys()  返回包含字典所有key的列表
		  dict.values()
		  dict.items()  返回包含所有（键，值）项的列表
		  dict.clear()  删除字典中的所有项或元素，无返回值(注意，不是删除字典，而是清空字典内容）
		  dict.get(key , default=None) 返回字典中key对应的值，若key不存在，则返回default的值（default默认为None）
		  dict.pop(key [,default])  如果字典中存在key，则删除并返回key对应的value；如果key不存在，且没有给出default值，则引发KeyError异常
		  dict.setdefault(key , default = None)  如果字典不存在key，则由dict[key] = default为其赋值
		  dict.update(adict)   将字典adict中键值对添加到dict中

遍历字典只需要遍历它的键

浅复制  ‘浅’指的是，复制的只是一个引用   （他们虽然是两个变量，但是变量的值是同一个）
	id( ) 的作用是找到变量或常量在内存中存的位置

深拷贝可以用引入copy模块实现
	copy.deepcopy

15/16. 数据类型 set
集合是一种不重复的无序集 集合用花括号来定义{}
集合的元素不可重复
集合里的元素需要是不可变类型，和字典中的键一样.所以集合可以理解为，只有键没有值的字典

创建  直接创建 集合元素是不可变类型所以可以使用数值，字符串，元组，
					而不能使用列表，字典当做元素值
			  创建时在集合中写了重复的值，不会报错，但根据互异性，只会保存一个
	  
	  set(obj)  obj可以使元组 列表  字符串

创建空集合要使用 set()
	而不能使用{}
	因为后者指的是创建空字典

操作方法：
set.add( x )  向集合中添加元素x
set.update(a_set)  使用集合a_set更新原集合,就是把括号里的集合的元素给set
set.pop( ) 删除并且返回集合中的任意元素  
				这里的删除是不能指定删除谁的，和列表的不一样
set.remove(x)  删除集合中的元素x，如果x不存在就报错
set.discard(x)  删除集合中的元素x，如果x不存在则什么也不做
set.clear( ) 清空集合中的所有元素

in 

交集 并集  差集  补集

	add()	为集合添加元素
	clear()	移除集合中的所有元素
	copy()	拷贝一个集合
	difference()	返回多个集合的差集
	difference_update()	移除集合中的元素，该元素在指定的集合也存在。
	discard()	删除集合中指定的元素
	intersection()	返回集合的交集
	intersection_update()	返回集合的交集。
	isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
	issubset()	判断指定集合是否为该方法参数集合的子集。
	issuperset()	判断该方法的参数集合是否为指定集合的子集
	pop()	随机移除元素
	remove()	移除指定元素
	symmetric_difference()	返回两个集合中不重复的元素集合。
	symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
	union()	返回两个集合的并集
	update()	给集合添加元素

17/18/19.函数
def 函数名（形式参数）：
函数体
[ return 返回值 ]
定义函数，函数名要符合变量命名规则，并且不能是系统关键字

函数名（实际参数）

函数调用写的参数是实际参数（‘实际’体现在参数是实际执行函数使用的）
函数定义写的参数是形式参数（‘形式’体现在他只是个格式和形式，真正函数执行时候还是先看实际参数）

函数调用时候，是将实际参数传递给形式参数
1.参数按照位置顺序传递
2.参数按赋值传递
3.参数按照默认值传递
4.（难点）元组类型的变长度参数传递
5.（难点）字典类型的变长度参数传递


无返回值的函数

函数中变量的作用域
	变量的作用域就是在程序中能对这个变量操作的区域范围

在函数外面，我们称之为全局变量（即它的作用域是全局的）

与之相对的，第二个和第三个a就成为局部变量
而且这个dayin_inner( ) 函数是被嵌套在 dayin_outer( ) 中的
值为 1 的 a 的作用范围是dayin_outer( )外层函数中
值为 2 的 a 的作用范围是dayin_outer( )内层函数中

不要将变量的作用域和变量重复赋值覆盖搞混

匿名函数 
	格式： 函数对象名 = lambda 形式参数：表达式

	findmax=lambda x,y : x if x>=y else y
	当函数较为复杂时，不建议匿名函数，不太好写而且结构难理解

函数的递归
	递归指的是一种直接或者间接调用自身的算法
	它的本质是将问题分解为同类型的子问题

def shulie(n):
	if n==1:
		return 1
	else:
		return shulie(n-1)

经典的Fibonacci数列问题

他做了如下的假设：　　
	1、新出生的小兔子在一个月的时间里发育为成年兔子；　　
	2、每对成年兔子每月繁殖一对小兔子（雌雄一对）；　　
	3、兔子没有死亡发生。
Fn代表n个月后兔子的对数. F0=1  F1=1 F2=2 F3=3 F4=5

月数  初生兔子   成年兔子   总数
1		1			0		1
2		0			1		1
3		1			1		2
4		1			2		3
5		2			3		5
前两项均为1，从第三项起，每一项都是其前两项的和
F0=F1=1，当n＞1时，Fn+2=Fn+1+Fn。
def Fibonacci(i):
	if i==0:
		return 0
	elif i==1:
		return 1
	else:
		return Fibonacci(i-2)+Fibonacci(i-1)

20/21/22.文件操作
绝对路径与相对路径

要打开这个文件操作也需要3个步骤：
	1.找出文件存放的路径，打开文件
	2.对文件修改操作
	3.关闭文件

from PIL import Image
img=Image.open('a.jpg')
img.show()

文件的编码   文本字符和二进制字节

在Python3.X中，字符串等所有的文本字符使用的是unicode编码，
可以使用encode（）进行编码为utf-8
使用decode（）可以将utf-8文件解码为文本字符

编码后的内容像个字符串，在字符串前面有个b，这个b表示的是二进制
	   encode ->
str---------------bytes
	  <- decode

文件写入
open() 加上文件的绝对路径或者相对路径可以打开文件
os模块是和操作系统相关的模块

import os
os.getcwd()
Out[11]: 'C:\\Users\\luwei'

f=open("testfile.txt",encoding='utf-8')

f.close()
f.read()  read（）方法相当于读取全部内容，如果读完内容，再次读取时候，书签已经在文章末尾，再次往后读当然没有内容啦~
f.readline()
f.readlines() 返回列表 
f.write()

g=[print(i) for i in f.readlines()]   
		 print() 函数作为列表的元素是没返回值的


i:	i=print('python')
o:	python
I:	print(i)
o:	None
i:	i
o:

23.异常处理
try…except…
try：
可能引起异常的代码
except：
对异常的处理代码

try...except...finally... 
	当finally之前出了异常，并且没有被捕获，照常执行finally中的内容

24.time模块

“”"