python学习笔记

1、求平方
y=PI*np.power(x,2)

2、导入函数库
import numpy as np
import matplotlib.pyplot as plt
import math as mt

-------------------
from numpy import *
# from matplotlib.pyplot import *
 
-------------------
3、快捷键
Alt+3 , Alt+4 代码的注释 和 去注释

Ctrl+[ , Ctrl+] 减缩进 和 加缩进

4、换行
print('Chenglin\nChenglin')
print(x,end=' ')#不换行，调试时，结束完才会输出。
 print('sin(%lf)=%lf\n'%(x,s))
sin(10.000000)=-0.544021
#打印格式控制

使用反斜杠（\）将一行语句分为多行显示
5、del s 删除变量

6、爬取网站信息
import urllib.request as ur
  str='http://www.baidu.com/'
    data=ur.urlopen(str)
    html=data.read()
    print(html)

7、python关键字
import keyword
>>> import keyword as kw
>>> kw.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>> 

8、VS2013编译python程序
#coding=gbk  #中文编码注释
#coding=utf-8  #中文编码注释
#
#程序功能：
#李承霖的python学习笔记

def fun():
    s='Chenglin Li'
    print(s)
    for i in range(5):
        print("result=%.2f"%(i*i))
    print(s)

def main():
    fun()

main()

9、分行显示字符串
s=('Chenglin Li'
   'Xiamen University'
   'Soochow University')
print(s)

>>> x=10
>>> y=20
>>> print(x,y)
10 20

print("%d:%d"%(index+1,item))

10、字符串类型
python字符串属于不变序列，通常使用单引号' ',双引号" ",或者三引号""" """、'''  '''。
三者在语义形式没有区别，只是在形式上有区别。
其中单引号，双引号中的字符序列必须在一行上，三引号内的字符序列，可以分布在连续多行上。

11、常用数据类型转换
int(x)、float(x)、complex(real [,imag])、str(x)
chr(x)将整数x转换为一个字符
ord(x)将一个字符转换为对应的整数值。
hex(x)将一个整数转换为16进制字符串
oct(x)将一个整数x转换为一个八进制的字符串
 s1='123'
    print('Chenglin Li'+s1)  #字符串类型的使用加号+连接
    x=123
    print('Chenglin Li'+123) #数字类型使用逗号，连接
print('x=%d'%(x))

12、算术运算符
+,-,*,/
%，求余。
>>> 13%2
1
//,取整除，返回商的整数部分。
>>> 13/2
6.5
>>> 13//2
6
>>> 
**幂，返回x的y次方。
>>> 2**10
1024
c=type(x) #获取数据类型
    print(c)

13、比较运算符
>,<,==,!=,>=,<=

14、逻辑运算符
and
or
not 

15、位运算符
位与&
位或|
位异或^
取反~
左移位<<
右移位>>

16、v=1+2j
print(v)
>>> v.real
1.0
>>> v.imag
2.0  
#提取实部和虚部

第三章：流程控制语句
1、flag=0
    if flag:
        print('My Xi')
    if not flag:
        print('Chenglin')
2、if 1>flag>-1 :
        print('flag=0')

3、循环语句
while 条件表达式：
    循环体

4、def loop():
    none=True
    i=0
    while none:
        i=i+1
        print(i,end=' ')#该语句调试时，不能即时输出。
        if i>5:
            none=False
            print()

5、for循环
for 迭代变量 in 对象：
    循环体
for i in range(1,10,2):
        print(i,end=',')  #不换行输出
-------------------------
result=0
    N=101
    for i in range(N):
        result+=i
    print(result)
-------------------------
range(start, stop,step) #内置函数
-------------------------
for num in range(100):
        if num%3==2 and num%5==3 and num%7==2:
            print(num,end=',')
    print()
------------------------
#打印9x9乘法表：
def fun99():
    for i in range(1,10):
        for j in range(1,i+1):
            print(str(j)+"x"+str(i)+'='+str(i*j)+'\t',end=' ')
        print()

第四章：序列的应用
一、序列概述
python内置了五个常用的序列结构，分别是列表、元组、集合、字典、字符串。
1、字典和集合不支持索引、切片、相加、相乘操作。
2、python的索引下标从0开始递增，也可以从右到左计数递减，最后一个元素的索引是-1.
3、切片：访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
sname[start: end: step]
sname[:] #复制整个序列的切片
4、序列相加
  c=[i for i in x]
>>> x
range(0, 10)

['Chenglin Li']
>>> s+c
['Chenglin Li', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

s='ChenglinLi '
>>> s1='QiuXi '
>>> s+s1
'ChenglinLi QiuXi '

x=np.arange(0,1,0.2)  #可输出浮点数
for i in x:
    print(i)

5、序列相乘
s='QiuXi'
>>> s*3
'QiuXiQiuXiQiuXi'

s1=['QiuXi']
>>> s2=s1*4
>>> s2
['QiuXi', 'QiuXi', 'QiuXi', 'QiuXi']

6、检查元素是否在列表
 c
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 0 in c
True
>>> 10 in c
False
>>> 10 not in c
True
>>> 

7、计算序列的长度、最值
n=len(c)
>>> n
10
>>> print(max(c))
9
>>> print(min(c))
0
>>> 
list(s)
['Q', 'i', 'u', 'X', 'i']
>>> print(max(c))
9
>>> print(min(c))
0
>>> print(sum(c))
45
type(c)
<class 'list'>
>>> type(list(c))
<class 'list'>

8、排序
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sorted(iterable[, cmp[, key[, reverse]]])
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
>>> sorted(c,reverse=True)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

9、切片操作（下标包含第一个数，不包含最后一个数）
x=list(range(10))
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x[:3]  #默认从0到2，步长是1
[0, 1, 2]
x[-10:]  #从右向左数，最右边的元素下标是-1，默认步长是1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[4:6]
[4, 5]

二、列表
1、创建列表：
使用赋值运算符直接创建列表：num=[1,2,3,4,5], s=['Cheng','lin','Li']
创建空列表：n=[ ]
创建数值列表：使用list()函数，将range()函数循环出来的结果转换为列表。
2、删除列表：del listname
3、访问列表元素：
>>> x=range(10,20,2)
>>> x=list(x)
>>> x
[10, 12, 14, 16, 18]
>>> x[3]
16
4、遍历列表
（1）使用for循环
for item in x:    
    print(item,end=',')
（2）使用enumerate函数和for循环
for index,item in enumerate(listname):
5、添加元素
listname.append(item)#添加一个元素
listname.extend(list2)#添加一个列表
listname.insert(index, obj)#插入指定下标处

6、修改元素
通过索引获取某一位置的元素，并为其重新赋值。
verse[2]=x2

7、删除元素
del verse[-1]

8、获取列表元素出现的次数
listname.count(obj)
s.append(2)
>>> s
[1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 1, 2, 2]
>>> s.count(2)
5
>>> s.insert(0,20)
>>> s
[20, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 1, 2, 2]
>>> s1=[8,5,3,2,1]
>>> s.extend(s1)
>>> s
[20, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 1, 2, 2, 8, 5, 3, 2, 1]
>>> del s[-1:-10:-1]
>>> s
[20, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2]
>>> 
>>> s.remove(20)
>>> s
[1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2]
>>> s.remove(1)#只删除一个元素
>>> s
[2, 3, 4, 5, 1, 2, 3, 4, 1, 2]
>>> 
>>> s.remove(1)
>>> s
[2, 3, 4, 5, 2, 3, 4, 1, 2]
>>> s.remove(1)
>>> s
[2, 3, 4, 5, 2, 3, 4, 2]
>>> 
>>> s
[20, 2, 3, 4, 5, 2, 3, 4, 2]
>>> none=True
>>> while none:
    if s.count(2)>0:
        s.remove(2)
        print(s)
    else:
        none=False

        
[20, 3, 4, 5, 2, 3, 4, 2]
[20, 3, 4, 5, 3, 4, 2]
[20, 3, 4, 5, 3, 4]

9、获取指定元素首次出现的下标
listname.index(obj)

10、统计数值列表的元素和
python自带的sum函数（或者Numpy中的sum函数）， 
无参时，所有全加； 
axis=0，按列相加； 
axis=1，按行相加；
sum(iterable, start)
参数
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
>>> sum(s,10)
49
>>> s
[20, 3, 4, 5, 3, 4]
>>> sum(s,10)
49
>>> sum(s)
39
>>> 

11、对列表进行排序
listname.sort(key=none,reverse=False)
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
 s.sort(reverse=True)
>>> s
[20, 5, 4, 4, 3, 3]
>>> s.sort()
>>> s
[3, 3, 4, 4, 5, 20]
>>> sorted(s)
[3, 3, 4, 4, 5, 20]
>>> sorted(s,reverse=True)
[20, 5, 4, 4, 3, 3]  #使用函数

12、快速生成一个列表（列表推导式）
>>> list=[x for x in range(10)]#使用range()函数生成列表
>>> list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> import random
>>> rn=[random.randint(10,100) for i in range(10)]  #生成随机数
>>> rn
[65, 13, 86, 90, 25, 41, 11, 32, 43, 91]
>>> d
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> new=[x*3 for x in d] #根据指定需求生成列表
>>> new
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> new1=[x for x in d if x>=5]  #从列表中选择符合条件的元素组成新的列表
>>> new1
[5, 6, 7, 8, 9]
>>> 

13、二位列表的使用
（1）、直接定义二维列表
>>> x=[[1,2,3],[4,5,6]]
>>> x
[[1, 2, 3], [4, 5, 6]]
>>> for i in range(2):  #遍历二维列表
    for j in range(3):
        if(j==2):
            print(x[i][j])
        else:
            print(x[i][j],end=',')            
1,2,3
4,5,6
>>>
>>> x[0] #第一行
[1, 2, 3]
>>> x[1] #第二行
[4, 5, 6]
>>> 
（2）使用列表推导式创建二维列表
>>> arr=[[j for j in range(5)] for i in range(4)]
>>> arr
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
>>> 
>>> s=[i for i in range(10,0,-1)]
>>> s
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> s.reverse()  #对列表进行逆序排列，从头到尾元素颠倒
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> 
>>> s1=[[1,2,3,4,5],[4,5,6,2,1]]
>>> s1
[[1, 2, 3, 4, 5], [4, 5, 6, 2, 1]]
>>> s1.reverse()
>>> s1
[[4, 5, 6, 2, 1], [1, 2, 3, 4, 5]]
---------------------------
（3）使用for语句循环创建
>>> a=[] #创建空列表
>>> for i in range(4):
    a.append([])  #在空列表中再添加一个空列表
    for j in range(5):
        a[i].append(j)        
>>> a
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
#二维列表使用列表推导式时，要慎重。
>>> s1=[[4, 5, 6, 2, 1], [1, 2, 3, 4, 5]]
>>> s1
[[4, 5, 6, 2, 1], [1, 2, 3, 4, 5]]
>>> s5=[[t*2 for t in s1[i]] for i in range(2)]
>>> s5
[[8, 10, 12, 4, 2], [2, 4, 6, 8, 10]]
>>> 
>>> v=[[1,2,3,4],[5,6,7,8]]
>>> v1=[[2**t for t in v[i]] for i in range(2)]
>>> v1
[[2, 4, 8, 16], [32, 64, 128, 256]]

三、元组
定义：元组是重要的数据结构，与列表类似，也是由一系列特定顺序排列的元素组成，但是它是不可变序列，也称为不可变列表。
形式上，元组的所有元素都放在()中，两个相邻元素间使用,分割。
在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入元组中。
通常情况下，元组用来保存程序中不可修改的内容。
1、元组的创建删除
·直接赋值：tuple=(ele1,ele2,ele3),
小括号不是必须的，只要将一组值用逗号分隔，就视为元组。tuple=ele1,ele2,ele3
>>> t=1,2,3,4
>>> t
(1, 2, 3, 4)
>>> t=('Chenglin',1,2,3,[2,3,4])
>>> t
('Chenglin', 1, 2, 3, [2, 3, 4])
>>> 
如果要创建的元组只有一个元素，则需要在定义时，元素后面加一个逗号，
>>> t1='Chenglin',#定义元组
>>> t1
('Chenglin',)
>>> t2='Chenglin' #定义字符串
>>> t2
'Chenglin'
>>> 
>>> type(t1)   #type()函数测试变量的类型
<class 'tuple'>
>>> type(t2)
<class 'str'>
>>> 
·创建空元组
emptytuple=()
>>> emptytuple
()
>>> 
空元组可以应用在函数传递一个空值，后者返回空值时。
·创建数值元组
可以使用tuple()函数直接将range()函数循环出来的结果转换为数值元组。
>>> x=range(20)
>>> tuple(x)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
>>> 
·删除元组
del tuplename

2、访问元组元素
>>> t
('Chenglin', 1, 2, 3, [2, 3, 4])
>>> for i in range(len(t)):
    print(t[i])
Chenglin
1
2
3
[2, 3, 4]
>>> print(t[:3])
('Chenglin', 1, 2)
>>> print(t[3:])
(3, [2, 3, 4])
>>> 

3、修改元组元素
必须对元组进行重新赋值。
可以对元组进行连接组合：
>>> t1='QiuXi',
>>> t
('Chenglin', 1, 2, 3, [2, 3, 4])
>>> t1
('QiuXi',)
>>> t=t+t1
>>> t
('Chenglin', 1, 2, 3, [2, 3, 4], 'QiuXi')
#元组连接时，连接的内容必须都是元组。

4、元组推导式
>>> import random
>>> rn=(random.randint(0,10) for i in range(10))
>>> rn
<generator object <genexpr> at 0x000001EFBE4F6620>#生成器对象
>>> r=tuple(rn)#转换成元组，转换后，rn被回收。生成器对象已经不存在了
>>> r
(5, 1, 9, 0, 4, 6, 5, 2, 5, 1)
>>> rn=(random.randint(0,10) for i in range(10))
>>> list(rn)
[4, 4, 8, 4, 4, 9, 0, 4, 10, 6]
>>> 

5、元组和列表的区别
·列表可变，元组不可变。
·元组不能使用append(),extend(),insert(),remove(),pop()等函数。元组没有。
·列表和元组都支持切片访问元素。
·元组比列表的访问和处理速度更快。
·列表不能作为字典的键，元组可以。

四、字典
定义:字典和列表相似，也是可变序列，但是它是无序的可变序列，保存内容是键-值对的形式存放的。
类似于拼音-汉字，键是唯一的，而值可以有多个。
字典的主要特征如下：
·通过键而不是索引来读取。
·字典是任意对象的无序集合。
·字典是可变的，并且可以任意嵌套。
·字典中的键必须唯一。
·字典中的键必须不可变。
·字典中的键可以使用"数字、字符串或者元组"，但不能使用列表。因为列表可变。

1、字典的创建和删除
键-值之间使用冒号分割，相邻两个元素只用逗号分隔，所有元素在一对{}中。
dict={'key1':'value1','key2':'value2',..}
#-------------方式1-------------------------------------
#推荐！！！
>>> dict5={'A':1,'B':2}
>>> dict5
{'B': 2, 'A': 1}
#--------------------------------------------------
·创建空字典：dictionary={}或者dicionary=dixt()
·通过映射函数创建字典：dict=dict(zip(list1,list2))
list1生成键，list2生成值。
>>> name
['Q', 'Y', 'D', 'M']
>>> sign=[1,2,3,4]
>>> del(dict)
#--------------方式2------------------------------------
#推荐！！！
>>> dict(zip(name,sign))#将两个列表组合成字典。
{'Y': 2, 'Q': 1, 'M': 4, 'D': 3}
#--------------------------------------------------
·通过给定的键值对创建字典
#---------------方式3-----------------------------------
#推荐！！
>>> d1=dict(Mary=1,Tom=2)
>>> d1
{'Tom': 2, 'Mary': 1}
#--------------------------------------------------
·通过已经存在的元组和列表创建字典
>>> name=tuple(range(10))
>>> sign=list(range(4))
>>> dict1={name:sign}
>>> dict1
{(0, 1, 2, 3, 4, 5, 6, 7, 8, 9): [0, 1, 2, 3]}
·删除字典
del dictname
dictname.clear()  #删除字典的全部元素。
>>> d1
{'Tom': 2, 'Mary': 1}
>>> d1.clear()
>>> d1
{}

2、通过键值对访问字典
索引元素要通过键来实现。
>>> dict1=dict(A=1,B=2,C=3)
>>> dict1['A']
1
>>> dict1
{'C': 3, 'A': 1, 'B': 2}
>>> for item in dict1.items():
    print(item)
('C', 3)
('A', 1)
('B', 2)
>>> for key,value in dict1.items():
    print(key,value)
C 3
A 1
B 2
--------------------
#不建议使用下列方式定义字典
>>> dict3={(1,2,3):['A','B','C']}
>>> dict3
{(1, 2, 3): ['A', 'B', 'C']}
>>> for item in dict3.items():
    print(item)

    
((1, 2, 3), ['A', 'B', 'C'])
>>> for key,value in dict3.items():
    print(key,value)

    
(1, 2, 3) ['A', 'B', 'C']
3、访问字典的键、值
>>> dict1.keys()
dict_keys(['C', 'A', 'B'])

>>> dict1.values()
dict_values([3, 1, 2])
使用get()方法获取指定键的值----！！推荐----
>>> d.get('D')
4
>>> 

4、字典中添加元素
dictname[key]=value
>>> dict1
{'C': 3, 'A': 1, 'B': 2}
>>> dict1['D']=4
>>> dict1
{'C': 3, 'A': 1, 'B': 2, 'D': 4}

5、字典中删除元素（删除键）
>>> del dict1['A']
>>> dict1
{'C': 3, 'B': 2, 'D': 4}

6、字典推导式
>>> import random
>>> rn={i:random.randint(10,100) for i in range(1,5)}
>>> rn
{1: 90, 2: 80, 3: 61, 4: 59}

五、集合
本书中要介绍的是可变集合是无序可变序列，不可变集合在本书中不作介绍。
形式上，集合的所有元素都放在一对{}中，两个相邻元素间使用逗号分隔。
集合最好的应用就是去掉重复应用，几何中每个元素都是唯一的。
1、创建集合
·使用{}创建集合setname={ele1,ele2,ele3,...}
元素的类型只要是python支持的类型就可以。
在创建集合时，如果输入了重复的元素，python会自动保存一个。
>>> set1={1,2,3,4,5,1,2,3}
>>> set1
{1, 2, 3, 4, 5}
·使用set()函数创建
可以使用set()函数将列表、元组等其他迭代对象抓换为集合。
setname=set(iteration)
>>> s1='Chenglin Li'
>>> set3=set(s1)
>>> set3
{'e', 'i', 'n', 'L', ' ', 'l', 'C', 'h', 'g'}
>>> x=[1,2,3,4,5,5,6,7,1,2,3]
>>> set4=set(x)
>>> set4
{1, 2, 3, 4, 5, 6, 7}

2、集合的添加和删除
setname.add(element)
>>> set4.add(8)
>>> set4
{1, 2, 3, 4, 5, 6, 7, 8}
>>> 
删除元素：
del setname  #删除整个集合
pop()/remove()删除一个元素
集合对象的clear()方法清空集合所有元素。
>>> set4
{1, 2, 3, 4, 5, 6, 7, 8}
>>> set4.remove(1)
>>> set4
{2, 3, 4, 5, 6, 7, 8}
>>> set4.pop()#弹出集合第一个元素
2
>>> set4
{3, 4, 5, 6, 7, 8}
>>> set4.clear()
>>> set4
set()

3、集合的交集、并集、差集运算
交集&、并集|、差集-
>>> t1=set(range(0,10))
>>> t1
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> t2=set(range(5,10))
>>> t2
{8, 9, 5, 6, 7}
>>> print(t1&t2)
{8, 9, 5, 6, 7}
>>> print(t1|t2)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> print(t1-t2)
{0, 1, 2, 3, 4}
>>> 

第五章、字符串和正则表达式

1、字符串常用操作
·拼接字符串：
>>> s1='ChenglinLi'
>>> s2='QiuXi'
>>> s1+s2
'ChenglinLiQiuXi'
字符串不允许与其他类型的数据拼接。
·将其他类型数据转换为字符串
str()函数
·计算字符串长度
len(string)
·截取字符串
strname[start:end:step]
>>> s1
'ChenglinLi'
>>> s1[:3]
'Che'
>>> s1[3:]
'nglinLi'
>>> s1[3:6]
'ngl'
>>> s1[0:10:2]
'CegiL'
>>> 
·分隔字符串
把字符串分割成列表，在该列表中，不包含分隔符。
strname.split(sep,maxsplit)
sep:指定分隔符，默认为none,可以是空格、换行\n、制表符\t
maxsplit:可选参数，指定分隔的次数，不指定默认为-1，次数没有限制。指定则返回列表的元素个数，个数最多为maxsplit+1。
返回值：返回分隔后的字符串列表。
-----------------？？上述用法不清晰------------------
·合并字符串
把列表合并为字符串
strnew=strsplit.join(iterable)
strsplit：用于指定合并时的分隔符。
iterable：可迭代对象，对象中的所有元素（字符串表示）将被合并为一个新的字符串，string作为边界点分隔出来。
>>> s3
['Best', 'wishes', 'to', 'You!']
>>> s4='@'.join(s3)
>>> s4
'Best@wishes@to@You!'
>>> s5=','.join(s3)
>>> s5
'Best,wishes,to,You!'
>>> d1
('A', 'B', 'C', 'D')
>>> d3=''.join(d1)
>>> d3
'ABCD'
>>> 
·检索字符串
count()方法：指定检索字符串在另一个字符串中出现的次数。
strname.count(substr)
>>> s='Chenglin Li'
>>> s.count('i')
2
find()方法：用于检索是否包含指定的子字符串，若不存在，返回-1，否则返回首次出现该字符串的索引。
strname.find(substr)
>>> s
'Chenglin Li'
>>> s.find('i')
6
>>> for t in s:
    print(s.find(t),t)
0 C
1 h
2 e
3 n
4 g
5 l
6 i
3 n
8  
9 L
6 i
>>> 
rfind()方法：与find()方法类似，从字符串右边开始查找。
>>> for t in s:
    print(s.rfind(t),t)
0 C
1 h
2 e
7 n
4 g
5 l
10 i
7 n
8  
9 L
10 i
>>> s
'Chenglin Li'
index()方法：与find()方法类似，制定的字符串不存在时，会抛出异常。
startwith()方法：检索字符串是否以指定子字符串开头，返回布尔类型。
>>> s
'Chenglin Li'
>>> s.startswith('C')
True
>>> s.startswith('i')
False
>>> 
endwith()方法：检索字符串是否以指定子字符串结尾，返回布尔类型。
>>> s.endswith('i')
True
>>> s.endswith('C')
False
>>> 
------------------------------------------------------
字母的大小写转换
lower()方法：将字符串中的大写字母->小写字母
upper()方法：将字符串中的小写字母->大写字母
>>> s
'Chenglin Li'
>>> s.lower()
'chenglin li'
>>> s.upper()#不改变原有字符串
'CHENGLIN LI'
>>> s
'Chenglin Li'
去除字符串中的空格和特殊字符
strip()方法：去掉字符串左右两侧的的空格和特殊字符。
lstrip()方法：去掉字符串左两侧的的空格和特殊字符。
rstrip()方法：去掉字符串右两侧的的空格和特殊字符。
>>> s1.strip('%*&^()')
'Chenglin Li999'
>>> s1
'%^&*)(Chenglin Li999*&^&*'
>>> s1.strip('%*&^()9')#参数可以指定多选字符
'Chenglin Li'
>>> 
-----------------------------------------------------
格式化字符串
使用%操作符：
‘%[-][+][0][m][.n]格式化字符’%exp
%s:字符串显示
%c:单个字符
%d或%i：十进制整数
%x:十六进制整数
%f:浮点数
%r:字符串
%o:八进制整数
%e:指数
%%:字符%
>>> print('%f=%f'%(3.1,3.5))
3.100000=3.500000
>>> print('%.2f=%.3f'%(3.1,3.5))
3.10=3.500
>>> print('%+4.2f=%+7.3f'%(3.1,3.5))
+3.10= +3.500
>>> 
使用字符串对象的format()方法
strname.format(args)
-------------------????------------------

3、正则表达式
(记录文本规则的代码)

第六章 函数
（实现某项工作的代码块）
>>> def fun():
    print('ChenglinLi')    #定义一个函数

>>> fun()#调用函数
ChenglinLi
>>> 
2、参数传递
·值传递：实际参数的值不变。
·引用传递：改变形式参数的值，实际参数的值也一同改变。
>>> fun(s33)
['A', 'B', 'C', 'D', [1, 2, 3], 3, 10, 10]
>>> def fun(s):
    s.append([1,2,3,4,5,6])
    print(s)
    return

>>> fun(s33)
['A', 'B', 'C', 'D', [1, 2, 3], 3, 10, 10, [1, 2, 3, 4, 5, 6]]
>>> s33
['A', 'B', 'C', 'D', [1, 2, 3], 3, 10, 10, [1, 2, 3, 4, 5, 6]]
>>> 
·函数调用参数时，数量和位置必须和定义时一致。
·关键字参数：使用形式参数的名字来去欸的那个输入的参数值，该方式不需要与形式参数的位置完全一致。
def pa(a,b):
    r1=a+b
    r2=a-b
    return r1,r2  #返回元组类型的数据

def main():
    r1,r2=pa(b=3,a=4)
    print(r1,r2)
main()

·为参数设置默认值
（指定默认的形式参数必须在所有参数的最后，否则将产生错误。默认参数必须指向不可变对象，否则多次调用可能产生意料之外的结果。）
def demo(obj=None):
    

    return 
------------------
def pa(a,b,c=10):
    r1=a+b+c
    r2=a-b-c
    return (r1,r2)
def main():
    (r1,r2)=pa(4,3)
    print(r1,r2)
main()

------------------------------------
定义可变参数1：
def change(*p):
    for item in p:
        print(item,end=' ')
    print()

    return 

def main():
    x=range(10)
    x=list(x)
    change(*x)
    x.append('Chenglin')
    change(*x)
main()
定义可变参数2：
表示接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。
def sign(**d):
    print()
    for key,value in d.items():
        print(key,value)
    return  #接收任意多显式赋值的参数

def main():

    d1='A B C D E'
    d1=d1.split()
    d2=list(range(1,6))
    d=dict(zip(d1,d2))
    sign(**d)
main()

4、变量的作用域
局部变量：在函数内部定义的变量，它只在原函数内部有效。
全部变量：作用于函数内外的变量：
（1）在函数外定义。
（2）使用global关键字修饰，该变量就成为全局变量。
在函数内部可以修改。
要想在函数内部对函数外面的全局变量进行修改，用到global关键字。
>>> x=1;
>>> def f():
    global x
    x=x+1  #对全局变量重新赋值
    print(x)
>>> f()
2
>>> f()
3
>>> f()
4
>>> 
5、匿名函数
需要一个函数，但是又不想命名这个函数。
格式：r=lambda[]:exp
import math
r=10
result=lambda r:math.pi*r*r
print(result(r))

-----------------------------------------------------------------
第七章、面向对象的程序设计
1、类：是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。
2、面向对象的程序设计的特点：
封装：将对象的属性和行为封装起来。
继承：是实现代码重复使用的重要条件，子类通过继承服用了父类的属性和行为，又可以添加子类特有的属性和行为。
多态：将父类对象应用于子类的特征就是多态。
3、类的定义和使用
3.1定义类：class关键字
class name:
    statement
如果在定义类时，没有想好类的具体功能，也可以在类中直接使用pass语句代替。
3.2、创建类的实例
className(parList)
3.3、创建__init__()方法
相当于构造方法，每当创建一个类的对象时，python都会自动执行它。
Note：该方法必须包含一个self参数，并且必须是第一个参数。
self参数是一个指向实例本身的引用，用于访问类中的属性和方法。
方法调用时，自动传递self。
除了self参数外，还可以自定义参数，用逗号隔开。
>>> class Geese:
    def __init__(self):
        print('大雁')        
>>> wild=Geese()
大雁
class Person(object):
    def __init__(self, name, lang, website):
        self.name = name
        self.lang = lang
        self.website = website
 
        print('self: ', self)
        print('type of self: ', type(self))

Python要self的理由：
Python的类的方法和普通的函数有一个很明显的区别，在类的方法必须有个额外的第一个参数
(self)，但在调用这个方法的时候不必为这个参数赋值（显胜于隐的引发）。Python的类的方法的这个特别的参数指代的是对象本身，而按照Python的惯例，它用self来表示。（当然我们也可以用其他任何名称来代替，只是规范和标准在那建议我们一致使用self）。
self在Python里不是关键字。self代表当前对象的地址。
------类属性的改写---------
class Person:
    name='QiuXi'
    age=12
    def printName(self):
        print(self.name)
        print(Person.name)

print(Person.name)
print(Person.age)
p=Person()
p.printName()
print(p.age)
print('-------------------')
Person.name='ChenglinLi'  #在类的外面改写类的属性
#不能通过类的对象改变类的属性
p1=Person()
p1.printName()
3.33、类/对象的属性
访问：可以通过类的名称或者对象的名称来点读取。
改变：通过类的名称来改变类的属性。
实例属性：
class Person:
    name='QiuXi'
    age=12
    def printName(self):
        print(self.name)
        print(Person.name)
p=Person()
print('%s,%s'%(p.name,p.age))
p.name='Chenglin Li'   #更改对象属性
p.gender='Male'  #如果赋值对象的属性不存在，则会自动生成对象属性。
print('%s,%s,%s'%(p.name,p.age,p.gender))
print('%s,%s'%(Person.name,Person.age))  #不改变类的属性。
>>>
QiuXi,12
Chenglin Li,12,Male
QiuXi,12
>>> 

------------------------------
3.4、创建实例方法
def funName(self,parList)
    statement
访问：instanceName.funName(parList)
--------------------------
类属性可以通过类名称，或者实例名访问。
class Swan:
    neckSwan='脖子长'  #私有成员
    def __init__(self):
        print(self.neckSwan) #实例方法中访问私有属性
        print(Swan.__neckSwan) #实例方法中访问私有属性
3.5、访问限制
属性或方法名前加
·单下划线：_foo，保护类型的成员，protected,只允许类本身和子类进行访问，不能使用from module import *语句导入。
·双下划线：__foo，private私有类型的成员，只允许定义该方法的类本身进行访问，也不能通过类的实例对象进行访问。
·首尾加双下划线：__foo__，表示定义特殊方法，一般是系统定义名字。
>>> class Swan:
    __neckSwan='脖子长'  #私有成员
    def __init__(self):
        print(self.__neckSwan) #实例方法中访问私有属性        
>>> swan=Swan()
脖子长
>>> swan._Swan__neckSwan
'脖子长'
>>> swan._Swan__neckSwan  #私有属性，通过实例名._类名__xxx的方式访问
'脖子长'

4、属性
4.1、创建用于计算的属性
通过@property装饰器，将一个方法转换为属性，可以直接通过方法名来访问方法，不需要再添加()，使代码简洁。
@property可以把一个实例方法变成其同名属性，以支持.号访问。
@property
def name(self):
    block
>>> class Rect:
    def __init__(self,width,height):
        self.width=width
        self.height=height
    @property
    def area(self):
        return self.width*self.height

    
>>> r=Rect()
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    r=Rect()
TypeError: __init__() missing 2 required positional arguments: 'width' and 'height'
>>> r=Rect(10,20)#创建类的实例
>>> r.area#输出类的属性
200
>>> 

5、继承
（实现代码的重用，被继承的类成为父类或基类，新的类成为子类或者派生类。）
格式：
class ClassName(baseclasslist):
    statement
baseclasslist:用于要指定的基类，可以有多个，类名之间用逗号分隔。如果不指定，将使用所有python对象的根类object.
class Fruit:
    color='绿色'
    def harvest(self,color):
        print(self.color)

class Apple(Fruit):
    color='红色'
    def __init__(self):
        print('Apple')

class Orange(Fruit):
    color='橙色'
    def __init__(self):
        print('Orange')

apple=Apple()
c1=apple.color
apple.harvest(c1)
orange=Orange()
c2=orange.color
orange.harvest(c2)#调用父类方法

5.1、方法重写
当基类中的某个方法不适用派生类时，就需要在子类中重写父类的方法。
class Fruit:
    color='绿色'
    def harvest(self,color):
        print('水果的颜色:',self.color)

class Apple(Fruit):
    color='红色'
    def __init__(self):
        print('Apple')
    def harvest(self,color):
        print('苹果的颜色:',self.color)

class Orange(Fruit):
    color='橙色'
    def __init__(self):
        print('Orange')
    def harvest(self,color):
        print('橙子的颜色:',self.color)   

5.2、子类调用父类的__init__()方法
需要在子类使用super()函数，来调用父类的__init__()方法
class Fruit:
    color='绿色'
    def __init__(self):
        print('父类：水果类')
    def harvest(self,color):
        print('水果的颜色:',self.color)

class Apple(Fruit):
    color='红色'
    def __init__(self):
        print('Apple')
        super().__init__()
    def harvest(self,color):
        print('苹果的颜色:',self.color)