python书册中文版https://docs.python.org/zh-cn/3.7/

python菜鸟教程https://www.runoob.com/python/att-string-replace.html

python详细教程https://www.w3cschool.cn/python3/python3-module.html    w3c 的资料比较好

目录

一、概述

二、运算符

三、容器

3.1列表

3.2元组

3.3字符串

四、函数

4.1内嵌函数

4.2闭包

4.3匿名函数

4.4递归

五.字典

5.1集合

六、文件

七.异常

八、EasyGui

九、继承

十、运算符的重载

十一、模块

11.1包

十二、爬虫

---

一、概述

pycharm里面代码Ctrl + Alt + L 代码格式化，ALT+n上一条代码复现，没有冒号结束和C不同，ctrl+n新建窗口，代码提示也是按Tab键，python里面没有大括号小括号靠缩进来表面是一个整体，if 条件: 语句 else:语句，BIF=Buit in function,输入使用Input(),使用dir(__builtins__)查看电脑里面有的内置函数，在交互式输入框输入dir(__builtins__)，如图所示哦。是两个下划线并列哦，一共是四个下划线，不要漏掉哦,然后下面可以通过help(BIF),比如help(input)，相当是现有值，在给值取名字，这个名字就是变量，+在打印中是连接符（在字符串中），使用变量之前，需要对其先赋值，分大小，等号是赋值的意思，左边是名字，右边是值，部分东西和c有点像，部分和matlab比较像，创建字符串的时候可以使用单引号，也可以使用双引号，如果我们要打印引号就需要使用\，也就是转移字符，print（“wo\'go”）,我们也可以使用原始字符的转义字符，就是在前面加上一个r,print(r"c:\")打印可以使用print()函数也可以使用变量名进行回显，如果需要得到一个跨越多行的字符串，就需要使用三重引号字符串，在脚本中使用\再按回车就可以实现换行，

print("请输入")
tmp=input()
guess=int(tmp)
if(guess==8):print("厉害")
else:if guess>8:print("大了")else:print("小了")
print("结束")

二、运算符

如果用户想多输入几次我们就要想到while循环，while 条件：and逻辑操作符，可以将任意表达式连接在一起，并得到一个bool类型的值，括号可以改变优先级（2<3）and(3>4),或者不使用括号,random里面有一个模板randint(),会返回一个随机的整数，python的数据类型，e计法12000记1.2e4,带小数的记为0.002记为0.2e-2布尔类型其实也是一个整数，true代表1，false代表0，类型转换，转为整形int（a）,转为浮点float（a），转换为字符串就是会加上一个引号str(a),type(a)可以判断变量的类型,或者使用instance(变量，类型)，instance（a,int）,返回一个bool类型，变量命名不能以数字开头，+-*/，都是正常的和计算器一样，如果要实现整数/整数的整数，需要使用//，%取余，**是代表2**3等同于2^3,运算符的优先级都是先乘除后加减，比较运算符的优先级高于逻辑运算符2>3and3>4,就可以不加括号，也可以加括号（2>3）and（3>4），-3**-2，结果是-1/9，幂运算符左侧的优先级低于幂运算符，右侧高于幂运算符，and,or,not,not4=not1,也就是说这里只有非零和零，因为not返回的是一个bool类型的值，整体来说就是幂运算符最高，正负号，算术操作符，比较操作符，逻辑运算符，在c中的else if()变为了elif 条件：

a=input()
b=int(a)
if b==1:print(b)
elif b==2:print(b+1)
else:print("erro")

三元操作符用一条语句来完成条件判断和赋值操作>>> small=x if x<y else y，为真就把x赋值给small，为假就把y赋值给small

assert(断言)，就是条件分支的近亲，当这个关键字后边的条件为假的时候，程序会自动崩溃，并抛出assertionError的异常，如果是正确的就没有关系，一般用在程序中一定要确保是对的情况下，就使用assert关键字，

while 条件：循环体

for 目标 in 表达式：循环体

teacher=["lihua","wansi","lisi"]
for each in teacher:print(each,len(teacher))

range(),语法就是range(起始数，终止数)， range(start, stop[, step]，也可以定义步长step,默认是1，产生的这个序列也是顾头不顾尾，起始数省略的话是从0开始，常常和for一起使用

for i in range(5):print(i)

注意条件分支循环后面的冒号一定不要忘记，break和continue和c一样，注意这两个语句是对循环有用，也就是for和while

三、容器

3.1列表

列表：打了激素的数组，列表里面可以放整数，浮点数，字符串，对象，1创建列表1）普通列表2）混合列表3）空列表{}和[]都可以，创建空列和表和混合列表

 member=["张三",1,1.2,[1,2,3]]member
['张三', 1, 1.2, [1, 2, 3]]
empty=[]empty
[]

想列表里面添加元素可以用append（）函数，数组名.append("李四")，这个函数只能传入一个参数，如果要同时传入两个人就需要使用扩张的方法比如extend([]),里面的参数是一个列表，insert(第一个参数是位置，第二个是参数),member.insert(1,"小王"),元素的索引和数组一样，member[1],从列表删除元素，第一remove(里面要是元素的内容),member.remove("小王")，第二种del member[1],列表是像栈一样可以用pop(),member.pop(),删除的是最后一个元素，有返回值就是删除的元素，还可以member.pop(1),列表分片，就是一次从列表中去出多个元素，虽然索引也可以去，但是一次就只能取一个，member[1:3]，member[:]拷贝，member[:1]等都是可以的

列表操作符列表比较大小首先是比较的第一个元素，只要第一个元素大就返回true,list[12,34]<list1[13,45],就会返回true,字符串可以+号来进行拼接，用*来控制打印的次数，list=list1+list2,list1*=3,把list1复制3次，在放入list1中，可以用in来判断元素是否在列表中，"张三"in member，但是这种方法不能用来判断列表中列表的元素，如果要判断可以使用1in member[2],member就是列表里面的列表，要访问列表里面的列表我们可以使用像二维数组的访问方法member[5][1],5代表的是第几个元素是列表，1是代表第五个位置是列表里面的第一个元素，列举dir(list),list下面的count()方法统计在列表中出现的次数，member.count("张三")，index()返回的是元素所在的下标，有两个参数member.index("张三"，起始元素位置，终止元素位置)，reverse()方法，让元素原地翻转，列表的排序方法sort（），member.sort(),sort(func,key,reverse=false),就是降序，member.sort(reverse=True)，拷贝程序只能使用分片的方法，不能=，等号是标签，这个标签是贴在值上的，赋值的方法相当于给这个列表取了两个名字

3.2元组

元组：戴上了枷锁的列表，列表和元祖是近亲关系，所以元组和列表在实际使用上是非常相似的，列表的权限有点大可以任意的插入和删除，元组不可以插入和删除，元组也不可以随意改变，创建元组我们用的是小括号，而数组我们是中括号，访问元组和访问列表是一样的都是使用下标的方式，逗号的小括号才是元组的灵魂

 type1=(1,2,3,4)
type(type1)
<class 'tuple'>temp=2,3,4#空元组eco=()
#只有一个元素的元组
tem=(1,)

如何删除字符串，虽然说元组不能修改但是我们可以覆盖，之后改变标签指向，只要标签值没有标签指向之后回收期会回收值

>>> temp=("张三","李四","王五")
>>> #使用+号，来追加之后就可覆盖了
>>> temp=temp[:2]
>>> #就是把元组拆开为两部分，中间再加上一个元组
>>> temp=temp[:2]+("黄",)+temp[2:]
>>> temp
('张三', '李四', '黄')

元组里面的东西不能随便删除但是可以使用切片的方式删除里面的元素，要删除元组可以使用del temp,*号也是可以用在元组，8*（8，）>>> 8*(8,)  结果(8, 8, 8, 8, 8, 8, 8, 8)，乘在这里是执行赋值的操作，成员操作符有in和not in也是可以用在里面的，李四"not in temp，

3.3字符串

字符串的操作和元组类似，

>>> str1="I love fish"
>>> str2=str1[:6]
>>> #访问里面的一个字符直接使用下标
>>> str1[5]
'e'
>>> 

字符串一旦定义就不能被修改，但是要改的话只能使用像元组的操作使用方式，比如执行插入操作，ALT+p重现上一次出现过的代码，str1=str1[:5]+"easy"+str1[5:]，列表元组字符串都属于序列，常用的字符串函数（方法）就是要和对象使用，caplitalize(),将,casefold是将所有大写字符变为小写字符，center(width)，将字符串显示居中，count(sub,[star,end]),返回sub在字符串里边出现的次数，start和end表示参数范围，find(sub,[sta]),检查sub是否包含在字符串中，如果有则返回索引值，否则返回-1，star和end表示参数的范围可以选择，说一下>>> str3.join("1234")  得到'1AAA2AAA3AAA4'把str3的字符加入到1,2,3，4中，

replace(old, new[, count])，[]代表可以省略，如果不省略就可以加逗号，str.replace("is", "was", 3);split(sep=None, maxsplit=-1)

>>> str5="i love fish"
>>> str5.split()
['i', 'love', 'fish']

split("I"),以I为空格切，strip([chars])默认删除前后的空格，也可以指定删除前面和后面的字符

>>> str8="sssaaa"
>>> str8.strip("s")
'aaa'
>>> str8
'sssaaa'

注意里面的str8除非重新幅值给他才可以改变的str8的值，

translate(table)

根据 table 的规则（可以由 str.maketrans('a', 'b') 定制）转换字符串中的字符。

>>> #希望把s转为b
>>> str7.translate(str.maketrans('a', 'b'))
' ssssbsbb'
>>> #返回一个映射
>>> str.maketrans('a', 'b')
{97: 98}
>>> #返回的是a,b的ASCII码

格式化字符串使用format(),>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world'>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world',还可以使用占位符形式

>>> "{a}love {b}{c}".format(a="I",b="fish",c="com")
'Ilove fishcom'
#数字的占位要在{0}，要在{a}之前
#这种写法是错误的
>>> "{a}love {b}{0}".format(a="I",b="fish",c="com")
'Ilove fishcom'

字符串独有的操作符

%c就是把ASCII码的数字转为字符比如97对应a,多个参数要用元组括起来，%s是格式化字符串，%d格式化整数

>>> "%c"%97
'a'
>>> '%c %c %c' % (97,98,99)
'a b c'
>>> '%s' % 'i love fish'
'i love fish'
>>> '%d %d %d'% (4,5,6)
'4 5 6'
>>> 

默认浮点数精确到6位，统一都是%号用来占位，%格式d,

>>> '%#o'% 12
'0o14'
>>> '%#ox'% 12
'0o14x'
>>> '%#x'% 12
'0xc'
>>> '%d#d'% 12
'12#d'
>>> '%#d'% 12
'12'
>>> '%0d'% 15
'15'

序列：列表，元组合字符串，都可以通过索引得到一个元素，默认索引从0开始，可以通过分片的方法得到一个范围内的元素的集合，有很多共同的关系操作符，list()把一个可以迭代的对象转换为列表，list就是每次循环得到一个，然后再把这个插入到列表中，len(a)l列表长度，max(a)返回最大值，

>>> tupl=(3,3,1,5,56,4)
>>> sum(tupl)
72
>>> sum(tupl+1)
>>> reversed(tupl)
<reversed object at 0x0000029CB5BDB070>#返回的是一个对象地址
>>> list(reversed(tupl))#转为list
[4, 56, 5, 1, 3, 3]

,enumerate把列表的索引值放入放入到列表中，以元组的方式放入

 tupl=(3,3,1,5,56,4)
>>> enumerate(tupl)
<enumerate object at 0x0000029CB5BF2780>
>>> list(enumerate(tupl))
[(0, 3), (1, 3), (2, 1), (3, 5), (4, 56), (5, 4)]

zip就是列表a和列表b,对应元素以元组打包放在list,没有配对的舍弃，有点像男女找对象，

>>> a=[1,2,3,4,5]
>>> b=[1,3,5]
>>> zip(a,b)
<zip object at 0x0000029CB59E6840>
>>> #上面反映的是迭代器对象
>>> list(zip(a,b))
[(1, 1), (2, 3), (3, 5)]

四、函数

函数，对象，模块，在 python 中，类型属于对象，变量是没有类型的：找函数是往上找，多个参数逗号隔开，函数

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响函数文档

  >>> def numa():"数字序列函数"print(numa)>>> #通过函数的-doc-方法来看函数的文档说明
  >>> numa.__doc__
  '数字序列函数'
  

  还可以使用help(编写的函数名)，关键自参数，正常函数的是顺序索引，关键字可以改变顺序，有关键字就是按照关键字索引了

  >>> def say(name,age):print(name,age)>>> say("zhansan",2)
  zhansan 2
  >>> say(age=8,name="李四")
  李四 8

  默认的构造参数就是当我们忘记传递参数的时候可以保证函数不出错，

  >>> def say(name='王五',age=1):print(name,age)>>> #比如忘记了传递程序还是可以正常
  >>> say()
  王五 1
  >>> say(age=2)
  王五 2

  收集参数当弄不清楚，函数有几个参数的时候，say(*parment)即可

  >>> def say2(*par,name):for each in par:print(each)print(name)>>> say2(1,2,3,4,name="23")
  1
  2
  3
  4
  23

  函数如果不写return，其实他已经默认返回None,python中可以返回多个值可以使用列表，只是进行了一个打包，

  >>> def backk():return>>> def  bac():return 1,3,4
  >>> def ba():return [1,2,3]

  正常情况下不能在函数中修改全局变量的值，但是如果非要修改可以使用global关键字

  x = 1def func():global xx = 2func()
  print(x)
  #输出：2 

  4.1内嵌函数

• 内嵌函数就是在函数内部在建立函数，就像人妻，只有在定义内嵌函数的时候使用，

  >>> def fun2():print("fun2被执行")def fun21():print("fun21被执行")fun21()>>> fun2
  <function fun2 at 0x000002B40804B0D0>
  >>> fun2()
  fun2被执行
  fun21被执行

  4.2闭包

• 闭包是在内嵌函数中的，外部函数的返回值一定要是内部函数，内部函数使用外部函数中定义的变量，闭包就是内嵌函数用到外面函数的变量，内嵌函数，不能修改外面函数变量的值，

  >>> def funx(x):def funy(y):#注意这里和内嵌函数有点不同闭包函数定义return x+yreturn funy#直接返回的闭包函数名>>> funx(2)(3)
  5

  有点像global这里又添加了一个关键字来修改外部函数的变量nonlocal,其实闭包怎么定义怎么返回没有关系，关键是nonlocal的使用

  >>> def fun2():x=1print("fun2被执行")def fun21():nonlocal xx=19print("fun21被执行",x)fun21()print(x)

  什么叫闭包就是对内嵌函数来说不可以直接调用外层的变量，如果要使用需要加上nolocal,下面这样执行是错的

  >>> def outside():var=5def inside():print(var)var=3inside()

  修改

  >>> def outside():var=5def inside():nonlocal varprint(var)var=3inside()print(var)

  如果使用了return那种形式访问的时候就需要函数名（）（）

  >>> def outside():var=5def inside():nonlocal varprint(var)var=3return inside>>> outside()()
  5

  4.3匿名函数

  python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多，省去了取名字的麻烦
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

  >>> def ds(x):return 2*x+2>>> #使用匿名函数
  >>> lambda x:x*2+2
  <function <lambda> at 0x000002B40804B8B0>
  >>> g=lambda x:x*2+2#x就是参数如果是多个就用逗号隔开
  >>> g(5)
  12
  #两个参数的
  >>> a=lambda x,y:x*2+2*y
  >>> a(3,4)
  14

  像C++的内联函数，过滤器filter(),这是属于内置的BIF,filter(function or None, iterable)当第一个参数为函数对象，第二个对象迭代参数作为，第一个函数的参数，把返回值为flase的去掉，如果第一个参数为None的话，第二个参数是一个列表对象，也是把列表中的flase的值去掉，

  >>> list(filter(lambda x:x%2,range(10)))
  [1, 3, 5, 7, 9]

  map函数和filter()函数一致，实现对迭代对象的映射，但是map不会过滤，map的第一个参数必须是函数对象，map的返回值是一个序列

  >>> list(filter(lambda x:x%2,range(10)))
  [1, 3, 5, 7, 9]
  >>> list(map(lambda x:x%2,range(10)))#map是只映射处理不做过滤
  [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
  

  4.4递归

• map会对数据进行处理，得到处理以后的数据，而filter是做过滤，把满足要求得数筛选出来，强大的map是可以接受多个序列作为参数                                                                                                                                                                                

•  ctrl+c可以强制截停程序，python为了保护程序默认程序的递归是100层，如果需要修改，要通过下面的语法，

  import sys
  sys.setrecursionlimit(1000)
  #爬虫的时候可能用到

  比如用递归求阶乘，普通实现

  def fac( a ):result=afor each in range(1,a):result*=eachreturn result
  num=int(input("输入"))
  b=fac(num)
  print(b)

  递归有进去也要有出来，有调用自身的行为，有停止条件

def jiecheng(number):if number==1:return 1else:return number*jiecheng(number-1)
number=int(input('请输入一个数'))
result=jiecheng(number)
print(number,result)

五.字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：字符串，列表，元组是是序列类型，而字典是属于映射类型，但是索引都是用通数组

>>> dict={'a':1,'b':2,'c':3}
>>> dict['a']
1
>>> dict={1:'wo',2:'de'}
>>> dict[1]
'wo'

创建空字典dict={},字典也是有添加删除操作

>> #添加元素到字典中
>>> dict['d']=4
>>> dict
{1: 'wo', 2: 'de', 'd': 4}
>>> #更新元素
>>> dict['d']=5
>>> dict
{1: 'wo', 2: 'de', 'd': 5}
>>> #删除元素
>>> del dict['d']
>>> dict
{1: 'wo', 2: 'de'}
>>> #删除所有条目
>>> del dict
>>> dict
<class 'dict'>

键和值最好唯一对应，键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

dict={[1]:23,'a':3}
TypeError: unhashable type: 'list'

>>> dict={(1,):23,'a':3}
>>> str(dict)
"{(1,): 23, 'a': 3}"
>>> len(dict)
2
>>> dict1={1:'zhansan',2:'lisi'}

formkeys(iterable,value=None)创建并返回一个新的字典，字典内置函数，dict也是一个对象，在python中也是无处不对象，

>>> dict.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> #如果设置值的话，他会匹配
>>> dict.fromkeys((1,2,3),'zhansan')
{1: 'zhansan', 2: 'zhansan', 3: 'zhansan'}
>>> dict.fromkeys((1,2,3),('zhansan','lisi','wangwu'))
{1: ('zhansan', 'lisi', 'wangwu'), 2: ('zhansan', 'lisi', 'wangwu'), 3: ('zhansan', 'lisi', 'wangwu')}

下面介绍dict的方法keys(),values(),items(),keys()就是得到字典的键，dict1.keys(),values()也是

>>> dict1=dict.fromkeys(range(5),'value')
>>> dict1
{0: 'value', 1: 'value', 2: 'value', 3: 'value', 4: 'value'}
>>> dict1.keys()
dict_keys([0, 1, 2, 3, 4])

items以把键和值以元组的方式打印出来

>>> dict1.items()
dict_items([(0, 'value'), (1, 'value'), (2, 'value'), (3, 'value'), (4, 'value')])

为了更加友好的防止越界访问的问题，比如上面dict1[8]访问会出问题,如果使用dict1.get(8),没有就不显示就行了in和not in也是可以使用的

>>> 8 in dict1
False

在这里查找的是键，而在序列中in和not in我们查找的是值，清空可以使用clear(),   这里函数哪里有一个问题还需要再看一下，clear的删除会把原来的源头给删除比如a={1:one,2:two},b=a,一旦a.clear(),b中的值将不再存在，copy()方法是一个浅赋值，只复制值，地址不复制

>>> a={1:'one',2:'two'}
>>> b=a.copy()
>>> c=a
>>> id(a)
2621062459328
>>> id(b)
2621062778368
>>> id(c)
2621062459328

a=b这种复制是深复制，复制之后不仅表面的值相同而且地址也是相同的，pop()在这里可以不是最后一个值pop(key),setdefault(key[,d]),如果与则返回字典里面的值，没有的话就把这个值添加到字典中，dict.update(dict2)
把字典dict2的键/值对更新到dict里

>>> a.popitem()
(2, 'two')
>>> a.setdefault(1)
>>> a
{1: None}
>>> a.setdefault("the")
>>> a
{1: None, 'the': None}
>>> a.setdefault(5,'five')
'five'
>>> a
{1: None, 'the': None, 5: 'five'}
>>> b={6:'zhansan',7:'wang'}
>>> a.update(b)
>>> a
{1: None, 'the': None, 5: 'five', '小': '白', 6: 'zhansan', 7: 'wang'}

{}花括号并不是字典的唯一，字典键值匹配才是关键，集合也还有{，不过在集合中的元素你就是我的唯一}，集合里面重复的东西会被踢出，

>>> a={1,2,3,4,5,1,1}
>>> a
{1, 2, 3, 4, 5}

try:检测范围
except Exception[as reason]：出现异常（Exception）后的处理代码

5.1集合

集合的元素是不可以索引的，你不能像数组那样来索引，创建集合1直接使用花括号，2使用set()工厂函数，set()里面可以传输序列,set会做两件事，一件事去除重复，另外一件是排序，如果不希望改变原来的集合相对顺序，就不要用set,可以通过for来访问集合，可以通过in和not in判断一个元素是否在集合中，集合的内置方法add(),移除是使用remove(元素)

>>> a={1,2,3,4,5,1,1}
>>> a
{1, 2, 3, 4, 5}
>>> set1=set([1,2,3,4,5,1,1])>>> set1
{1, 2, 3, 4, 5}
>>> 1 in set1
True
>>> set1.add(6)
>>> set1
{1, 2, 3, 4, 5, 6}
>>> set1.remove(6)
>>> set1
{1, 2, 3, 4, 5}

集合的元素不可以顺便变化，有不可变集合。forzenset

>>> set2=frozenset([1,2,3,4,5])
>>> set2
frozenset({1, 2, 3, 4, 5})
>>> set2.add(7)

六、文件

文件打开使用open()

把文件对象转为list(f)

>>> f=open('D:\\tmp\python\score.txt','r+',encoding='UTF-8')
>>> f.tell()
0
>>> #0是文件所在的位置
>>> f.seek(2,0)
2
>>> f.tell()
2

文件内所有的东西都读出来

>>> for each in f:print(each)高三五班的成绩小甲鱼第一

os 模块提供了非常丰富的方法用来处理文件和目录，os模块的函数需要先实现，chdir(path)，里面通过就是路径名chdir('E:\\A')两个\\其中有一个是转义字符，打开cmd,os.system('cmd')

>>> import os
>>> os.getcwd()
'C:\\Users\\taobao\\AppData\\Local\\Programs\\Python\\Python38'
>>> os.chdir('E:\\')
>>> os.getcwd()
'E:\\'
>>> #列举出所有的文件名
>>> os.listdir('E:\\')

 

用点表示当前目录，用点点表示上一层目录，os.path下面的方法是独立的，写方法的时候一定是os.path.fun('路径')

>>> os.path.basename('E;\\A')，文件夹就是一个文件目录，绝对路径在哪里就写全了包含盘符的

>>> import time
>>> localtime(os.path.getatime('D:\\tmp\python\score.txt'))

pickle模块可以把所有的文件转为二进制的形式进行存储，之后再恢复出来，dump(par1,par2),第一个参数是倒入的内容，第二个参数是方式和文件名

>>> com=[1,3,'小鱼']
>>> file=open('E：\\A\com.pkl','wb')
>>> #上面的wb就是以二进制的形式
>>> pickle.dump(com,file)
>>> #和文件类似也要关了
>>> file.close()
#加载文件
>>> #使用load加载出来
>>> filemn=open('D:\\tmp\python\com.pkl','rb')
>>> come=pickle.load(filemn)
>>> come
[1, 2.3]

文件名后缀是pkl,

七.异常

异常：常见的异常如下

捕获异常使用

try:f=open('我为什么是一个文件.txt')print(f.read())f.close()
except OSError:print('文件出错')

 

try:语句块
except 错误类型[as reason]:出现错误的处理方法

try:f=open('我为什么是一个文件.txt')print(f.read())f.close()
except OSError:print('文件出错')

一个try可以搭配多个except

try:sum=1+'1'f=open('我为什么是一个文件.txt')print(f.read())f.close()except OSError as reason:print('文件出错原因是：'+str(reason))
except TypeError as reason:print('文件出错原因是：'+str(reason))

可以使用不带参数的捕获所有异常

try:正常的操作......................
except(Exception1[, Exception2[,...ExceptionN]]]):发生以上多个异常中的一个，执行这块代码......................
else:如果没有异常执行这块代码

还可以把多个参数放在except中

try:sum=1+'1'f=open('我为什么是一个文件.txt')print(f.read())f.close()except (OSError,TypeError) :print('有异常')

try-finally 语句无论是否发生异常都将执行最后的代码

try:
<语句>
finally:
<语句>    #退出try时总会执行

try:sum=1+'1'f=open('我为什么是一个文件.txt','w')print(f.read())f.close()except (OSError,TypeError) :print('有异常')
finally:print('保存文件')

raise语句自己可以引发一个异常，

>>> raise NameError('命名异常')
Traceback (most recent call last):File "<pyshell#135>", line 1, in <module>raise NameError('命名异常')
NameError: 命名异常

丰富得else语句，在python中不仅可以和if搭配还可以和for,while还有异常语句搭配，简洁的with语句with主要用来关闭自动打开的文档，通过我们会使用finally: f.close(),关闭文件，但是这条语句当文件没有打开时就会产生异常，使用with open('data1.txt','rt')as f:代替f=open(open('data1.txt','rt')),else和for和while进行搭配，只有当循环正常执行完之后才会执行else的内容

i=2
while i<3:i+=1print('函数内')
else:print('函数外')

八、EasyGui

图形用户界面入门EasyGui

GUI中文链接https://www.cnblogs.com/hale547/p/13301951.html?utm_source=tuicool

GUI官网文档地址http://easygui.sourceforge.net/sourceforge_site_as_of_2014_11_21/download/version_0.96/doc/epydoc/index.html

import easygui as g,以后g就代表easygui

Python pass 是空语句，是为了保持程序结构的完整性,pass 不做任何事情，一般用做占位语句。

对象=属性+方法，类名默认以大写字母开头，

class ClassName:'类的帮助信息'   #类文档字符串内容

这里的self等于我们之前使用的this,注意这里面的self在写函数的时候是必须的参数，虽然在调用参数的时候可以不传递，C++默认自己有this不传，

class Employee:'所有员工的基类'empCount = 0name='wo'def writeName(self,name):self.name=nameprint(self.name)

第一种方法__init__()方法是一种特殊的方法，注意是两个_，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法，类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self，多态就是比如同一个函数名在不同的类中实现方法不同，公有的默认对象的属性和方法都是公开的，在python中定义私有变量只需要在变量或函数名前加上__两个下划线，那么这么函数或变量就会为私有，__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs，实际上的一个处理方法是修改了私有变量的名字，如果在外层也要访问需要使用对象.类名.对象名 ,继承写法class 派生类名(基类名)，可以对里面的方法重载

class A:def Afun(self):print('T am A')
class B:__banji=''def Bfun(self,nianji):banji=nianjiprint('I am B'+banji)
class Ason(A):pass
class Bson(B):#对方法重写def Bfun(self,nianji):print('调用的是子类的方法')
ason=Ason()
ason.Afun()
bson=Bson()
bson.Bfun('二年级')

python的内置类属性__dict__ : 类的属性（包含一个字典，由类的数据属性组成），调用方法是类名.l类的属性， A.__dict__，显示子类所有的爸爸Ason.__bases__，析构函数 __del__对象销毁的时候被调用，当对象不再被使用时，__del__方法运行

    def __del__():print('销毁')

删除对象del 对象名

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。

• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

九、继承

组合式指一个对象中包含一个或者多个对象，super.__init__():　我理解是，当需要继承父类构造函数中的内容，且子类需要在父类的基础上补充时，使用super().__init__()方法，比如下面的学生类和日期类，他们之间的关系不是继承需要互相配合

class People:def __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sex print(name,age,sex)#学生类
class Student(People):def __init__(self,name,age,sex):super().__init__(name,age,sex)#日期类
class Date:def __init__(self,year,month,day):self.year = yearself.month = monthself.day = daydef tell_birth(self):print(f'''===== 出生年月日 =====年: {self.year}月: {self.month}日: {self.day}''')stu1 = Student('baohan',18,'male')
date_obj = Date(2001,6,23)#学生对象中包含一个自定义日期对象
stu1.date_obj = date_obj
# print(stu1.date_obj.year, stu1.date_obj.month, stu1.date_obj.day)
stu1.date_obj.tell_birth()

最后的结果就是baohan 18 male 2001 6 23，关键是下面的语句，s1.d1 = d1，s1就可以通过是s1.d1调用d1的方法和属性

s1 = Teacher('wanglu', 18, 'female')
d1 = Date(1997, 1, 29)
s1.d1 = d1
d1.tell_birth()
print(s1.d1.tell_birth())

有交叉关系的就可以使用组合，类里面的变量值是大家的公共的，实例化对象之后，对象的变量是私有的，改变实例化的变量不会影响到公共类的对象，

python中的方法需要实例化后才能被调用，并且里面的属性和方法是静态的有点类似static，删除类之后之前实例化好的的对象依然可以使用类里面的方法，因为是这些静态的东西只有程序结束之后才能被释放，

>>> ss=A()
>>> del A
>>> ss.dprint()
被执行

在Python3中子类在继承父类的时候，当子类中的方法与父类中的方法重名时，子类中的方法会覆盖父类中的方法，

那么，如果我们想实现同时调用父类和子类中的同名方法，就需要使用到super()这个函数，用法为super().函数名()

class A3():def go(self):print("go A3 go")class C(A3):def go(self):print("go C go")super().go()d1 = C()
d1.go()

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(子类,父类)，isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true

class A3():def go(self):print("go A3 go")class C(A3):def go(self):print("go C go")super().go()d1 = C()
d1.go()
va=issubclass(C,A3)
fv=isinstance(d1,C)
fv1=isinstance(d1,A3)

对象的属性hasattr(object,name),就是看对象有没有对应的属性注意name里面的东西需要‘’

class C():def __init__(self,x=0):self.x=xprint("go A3 go")
d1 = C()
d2=hasattr(d1,'x')

getattr(object,name[,defalult]),当查找失败的时候会打印defalult里面的内容

class C():def __init__(self,x=0):self.x=xprint("go A3 go")
d1 = C()
d2=getattr(d1,'y','没有')

setattr(object,'name',value)如果没有name属性，就新建一个name并设定值，注意是设置对象的属性，不是类的属性d1 = C()
d2=setattr(d1,'y','没有')，delattr(obejict,name),删除对象中指定的属性，如果属性不存在就抛出异常property(fget=None, fset=None, fdel=None, doc=None)，用属性来设置属性，如果c是C的一个实列, c.x 将掉用getx, c.x = value 调用set并且调用del c.x 讲调用 delx

class C:def __init__(self):self._x = 3def getx(self):return self._xdef setx(self, value):self._x = valuedef delx(self):del self._xx = property(getx, setx, delx, "I'm the 'x' property.")
>>> c1=C()
>>> c1.x
3
>>> c1.x=10
>>> c1.x
10
>>> del c1.x
>>> cl.x
Traceback (most recent call last):File "<pyshell#258>", line 1, in <module>cl.x
NameError: name 'cl' is not defined

构造函数如果用参数，创建对象的时候也需要传入参数

十、运算符的重载

运算符的重载，首先下面的图一和图二说明了运算符在python对应的函数，如果要重写直接写一个和运算符重载的函数名就会优先调用我们自己写的，3+a,左边是内置类型，右边是自定义类型就会调用反向运算符

                             图一                                                                                           图二

 
class Vector:def __init__(self, a, b):self.a = aself.b = bdef __str__(self):return 'Vector (%d, %d)' % (self.a, self.b)def __add__(self,other):return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

__gerattr_(self,name)定义当用户试图获取一个不存在的属性时的行为

>>> class C:def __setattr__(self,name,value):print('getattibute')return super().__setattr__(name,value)>>> c=C()
>>> c.x=1
getattibute

描述符就是将某种特殊类型的类的实例指派给另一个类的属性，__get__(self,instance,owner),至少要含有以下函数中的一个才能叫特殊类型，总体的的一个思路就是把特殊类的方法封装起来作为另外一个类的属性，之后就可以通过c.x,还是c.x='name',来决定调用的方法

十一、模块

import 模块名称 

from 模块名称 import()方法名

__len__(self)	定义当被 len() 调用时的行为（返回容器中元素的个数）
__getitem__(self, key)	定义获取容器中指定元素的行为，相当于 self[key]

class Count:def __init__(self,*arg):self.value=[x for x in arg]self.cout={}.fromkeys(range(len(self.value)),0)def __len__(self):return len(self.values)def __getitem__(self,key):#容器中的元素被访问的时候会自动调用self.cout[key]+=1print('我被执行了')return self.value[key]

迭代器有两个基本的方法：iter() 和 next()，字符串，列表或元组对象都可用于创建迭代器，还可以使用next(it)进行遍历

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:print (x, end=" ")#横向打印

生成器就是一个迭代器，使用了 yield 的函数被称为生成器（generator），在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行，生成器就是一个特殊的函数，yield有点像我们普通函数的return语句，但是不同的是yield会暂停，不会结束程序，函数里面有yield就变成了生成器StopIteration是迭代器结束异常，也就是说我们迭代完了

>>> def myge():yield 1yield 2>>> #yield
>>> my=myge()
>>> next(my)
1
>>> next(my)
2
>>> next(my)
Traceback (most recent call last):File "<pyshell#59>", line 1, in <module>next(my)
StopIteration
>>> for i in my:print(i)>>> my=myge()
>>> for i in my:print(i)1
2

python还有列表推导，就是做一个列表不能被2和3整除

>>> a=[i for i in range(100) if not(i%2)and i%3]
>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]

还有字典推导式

>>> b={i:i%2==0 for i in range(10)}
>>> b
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

还有集合推到式，集合会把重复的去掉

>>> c={i for i in [1,1,3,4,5,5,6]}
>>> c
{1, 3, 4, 5, 6}

但是没有字符串推导式和元组推导式，元组推导得到是生成器generator,生成器就可以使用生成器的方法

>>> e=(i for i in range(10))
>>> e
<generator object <genexpr> at 0x0000025F7F8FAA50>

模块的第二种导入模式方式就是从模块中导入函数from 模块名 import 函数名

>>> from file import hi
>>> hi()
mokuai

如果觉得一个一个的导入比较麻烦的话可以用 from file import *,还有第三种方式import 模块名 as 新名字,

有一些内建、隐含的变量，__name__就是其中之一，其意义是“模块名称”。

如果该模块是被引用，那么__name__的值会是此模块的名称；如果该模块是直接被执行，那么__name__的值是__main__

def hi():print('mokuai')def test():print('函数正常')
if __name__=='main':test()

通过下面的程序可以把模块放在任意位置，注意所有的\都要变为\\

>>> import sys
>>> sys.path
[C:\\Users\\taobao\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages']
>>> import sys
>>> sys.path.append('D:\\wode')
>>> sys.path

11.1包

文件夹的名字就是包的名字，文件夹里面一定要有一个__init__.py一定要有空文件都可以，导入包的标志，通过import 包名.模块名>>> import packge.one >>> import packge

快速学习一个模块的方法，首先进入help文档搜索模块名，让后在脚本行import 模块，之后使用print（模块名.__doc__）查看简明版说明，看模块里面的变量可以使用dir(模块名)

十二、爬虫

>>> print(timeit.__doc__)
Tool for measuring execution time of small code snippets.This module avoids a number of common traps for measuring execution
times.  See also Tim Peters' introduction to the Algorithms chapter in
the Python Cookbook, published by O'Reilly.Library usage: see the Timer class.Command line usage:python timeit.py [-n N] [-r N] [-s S] [-p] [-h] [--] [statement]Options:-n/--number N: how many times to execute 'statement' (default: see below)-r/--repeat N: how many times to repeat the timer (default 5)-s/--setup S: statement to be executed once initially (default 'pass').Execution time of this setup statement is NOT timed.-p/--process: use time.process_time() (default is time.perf_counter())-v/--verbose: print raw timing results; repeat for more digits precision-u/--unit: set the output time unit (nsec, usec, msec, or sec)-h/--help: print this usage message and exit--: separate options from statement, use when statement starts with -statement: statement to be timed (default 'pass')A multi-line statement may be given by specifying each line as a
separate argument; indented lines are possible by enclosing an
argument in quotes and using leading spaces.  Multiple -s options are
treated similarly.If -n is not given, a suitable number of loops is calculated by trying
increasing numbers from the sequence 1, 2, 5, 10, 20, 50, ... until the
total time is at least 0.2 seconds.Note: there is a certain baseline overhead associated with executing a
pass statement.  It differs between versions.  The code here doesn't try
to hide it, but you should be aware of it.  The baseline overhead can be
measured by invoking the program without arguments.Classes:TimerFunctions:timeit(string, string) -> floatrepeat(string, string) -> listdefault_timer() -> float>>> dir(timeit)
['Timer', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_globals', 'default_number', 'default_repeat', 'default_timer', 'dummy_src_name', 'gc', 'itertools', 'main', 'reindent', 'repeat', 'sys', 'template', 'time', 'timeit']
>>> #再次使用timeit.__all__过滤掉无用的属性
>>> timeit.__all__
['Timer', 'timeit', 'repeat', 'default_timer']
>>> #上面显示的是几个外面可以使用的类
>>> #源码的文件位置
>>> timeit.__file__
'C:\\Users\\taobao\\AppData\\Local\\Programs\\Python\\Python38\\lib\\timeit.py'

还可以通过help(timeit)

爬虫，python 如何访问互联网，第三部分是资源的具体地址，如目录或文件名等，爬虫部分不全以后有机会补上

使用这个来请求网页urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)

>>> import urllib.request
>>> response=urllib.request.urlopen('http://www.biqukan.com/')
>>> html=response.read()
>>> print(html)
>>> #上面是二进制码

解析网页数据时偶尔会出现乱码，这是由于编码格式不对导致的，这时我们就需要知道网页源码的编码方式

解决办法：

以http://stock.jrj.com.cn/2018/12/04000025448047.shtml为例

1. 使用谷歌浏览器打开网页
2. 右键—>检查
3. 点击Console
4. 输入document.charset，然后回车

   >>> html1=html.decode('GBK')
   >>> print(html1)