python笔记

这篇笔记是去年寒假看视频的时候总结的，比较杂，算是对python的初步了解，先贴出来，以后有空再做系统的整理和补充。

---

杂项

0、字符串前面加r 原始字符串 省去所有转义 但最后不能有反斜杠
三重引号字符串”“” “”” 打印长字符串

---

1、if while else 后面要加冒号

---

2、isinstance 测试类型 isinstance(a,int)为true表示a是int，false表示不是
type也可以用来查看类型
num = 1
type(num) # 结果是int

---

3、//表示地板除法 整数除整数 为整数 向下取整
/为真正的除法
** 次幂运算 比左侧的数优先级高 比右侧的优先级低 -3**2 = -(3**2) -3 ** -2=-(3**(-2))
非0都是true,true==1,false==0
2<3<4 <==> 2<3 and 3<4
优先级
幂>正负号>算数操作>比较>逻辑

---

4、elif 就是 C的else if
python可以避免悬挂else if 和 else不匹配的情况
x if 条件 else y
if x < y:
small = x
else:
small = y

---

5、断言 assert 自爆函数 当后边条件为false时 程序报错 当后面是true 就pass 相当于是检查点

---

6、python的for循环更加智能和强大 会自动调用迭代器的next并捕获迭代器的结束

for 目标 in 表达式:
    循环体 

---

7、for的小伙伴 range
range([start,]stop[,step=1])
默认从0开始，步长为1，不包含stop的那个数

>>>for i in range(2,10,2):
    print(i)
2
4
6
8
>>>

---

8、break 终止当前循环
continue 终止本轮循环并开始下一轮，首先要测试循环条件，满足则开始，否则会推出循环
会被看做假的内容：
False、None、0、”“、”、()、[]、{}，其余都是真

---

9、列表

list,可以把任何数据类型打包进列表
创建普通列表 number = [1,2,3,4,5]
创建混合列表 mixture = [1,2.3,’4.5’,[6,7,8]]
创建空列表 empty=[]
添加元素 append() extend() insert()

>>>number.append(6) #只能一个个的加入
>>>number.extend([7,8]) #使用一个列表扩展另一个列表
>>>number.insert(0,'0') #在第0个位置插入元素'0'

获取元素 number[5]索引值
删除元素 remove(1) #删掉元素1 当要删除的元素不在列表中则会报错
del number[1] #不是一个函数 是一个语句 删掉指定元素 也可以删掉整个列表
pop() #不带参数 则会返回最后一个参数并删掉 列表原理是堆栈
pop(1) #也可以带参数 取出并删掉第1个元素
列表分片 slice 一次性获取多个元素

>>>number[1:3] #分出两个元素 从1到3 不包含3 得到原列表的一个拷贝 :前省略表示从头，之后省略表示到尾
>>>member=number[:]#获得完整拷贝 互不影响 实实在在的拷贝一次 
>>>member=number #会受到number修改的影响 指定另外一个名字 只是相当于再添加一个名字

列表删除 clear() 清空全部元素 但列表还在
列表复制 copy()
列表比较操作 从第一个开始比较 第0个赢了整体就赢了
列表逻辑操作 和其他的一样
列表运算操作 值拼接在一起 相当于extend方法 加号两边类型必须一致
列表重复操作 乘号* 将原列表重复多次接在后面
列表成员关系操作 in 和 not in ,列表中的列表的成员不能直接用 in /not in

>>>list = [1,[9,10],100]
>>>9 in list[1]
True

类比访问二维数组的方法访问上面的9 ==> list[1][1]=9
列表的小伙伴
计算参数在列表中出现的次数 count()
返回参数在列表中第一次出现的位置 index() #后接第二第三两个参数可以卡住范围
列表整体镜像 最前的排最后 最后排最前 reverse()
用指定方式对列表排序 sort(func,key,reverse) #默认是(升序排列,归并排序,false)
*列表推导式
[有关A的表达式 for A in B]
list1 = [x**2 for x in range(10)]
list1 = [0,1,4,9,16,25,36,49,64,81]
类似还有list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]

---

10、元组

tuple 不可改变的类型 定义之后不可改变
与列表非常相似，
创建和访问元组 用小括号

>>>tuple1 = (1,2,3,4)
>>>tuple2 = () #创建空元组
>>>tuple3 = 1，#创建元组

用索引访问
分片的办法与列表相同
元素不可以修改 tuple[1] = 2 会报错
加上小括号也不一定是元组
没有小括号也不一定不是元组
逗号才是关键

>>>8*(8,) # 重复8次

添加元素 相当于在原有基础上插入新元素，构成新元组，在复制回原元组

>>> temp = (1,2,3)
>>> temp = temp[:1]+(1.5,)+temp[1:] #括号和逗号都是关键！`原元组还在但是没有标签指向他，过段时间会被删掉
>>> temp
(1, 1.5, 2, 3)

删除元素 del temp #删除整个元组
拼接操作符 、重复操作符、成员操作符、逻辑操作符和列表都是相似

---

11、字符串

str
str1 = ‘1234567890’
str1[:3]= ‘123’
str1[3] = ‘4’ #其实是个子字符串
str1[:3]+’66666’+str1[3:] #插入的方法和元组类似
str的很多方法方法，返回一个新的字符串 原字符串没有被改变
join 把子字符串作为分隔符插入到字符串中

>>>str1.join('x') #str1就会变成1x2x3x4

partition(sub) 转换成3元组(sub之前,sub,sub之后)
split以空格来分片

---

12、格式化字符串
format方法 参数 位置参数和格式化参数 replacement

>>> "{0} love {1}".format("I","U")
'I love U'
>>> "{
   {0}}".format("x") #两层括号 可以打印出括号
'{0}'
>>> '{0:.2f}{1}'.format(12.3456,'GB') #:表示表示一个是字符串的开始 .2表示四舍五入保留两位小数
'12.35GB'

---

13、序列

列表、元组、字符串 都是序列
list() tuple() str()带参数则是将所给的序列转换为对应的类型
len() 求长度
max() min() 返回序列的最大值 最小值
sum() 求和
sorted() 排序
reversed() 返回迭代器对象 用list()在生成一次就可以显示了
enumerate()枚举 把每一个元素变成一个元组，在元素前插入索引值构成一个元组
zip() 返回各个参数的对应索引位置构成的元组组成的的序列

>>> a=[1,2,3,4,5]
>>> b=[1,2,3]
>>> zip(a,b)
<zip object at 0x000000DED512A908>
>>> list(zip(a,b))
[(1, 1), (2, 2), (3, 3)]

---

14、函数

函数定义

>>> def MyFunc(num1,num2):
    print('-------------')
    print('first func')
    print('-------------')
    return(num1+num2)

>>>

函数调用

>>> MyFunc(5,6)
-------------
first func
-------------
11
>>>

调用时向上寻找函数定义的位置

函数文档

不同于注释
函数下方的一个字符串 functionNmae.doc可以打印出函数文档，用help也可以访问到函数文档

关键字参数

给参数下个定义（形参=实参 eg. func(name = “LYY”，age=21)），
顺序改变就不会出现问题
可以设置默认参数值，使得不用输入参数也可以有默认值

收集参数

在参数前面加上星号，就变成了可变参数。如果有普通参数和收集参数混合，则需要指定关键字参数

>>> def prac(*para,exp = 8):
    print('length',len(para))
    print('second',para[1])
    print(exp)


>>> prac(1,(1,2,3),'134',exp = [1,2,3])
length 3
second (1, 2, 3)
[1, 2, 3]
>>> 

函数和过程

有返回值是函数
无返回值是过程 python原则上是没有过程的
局部变量和全局变量的区别和操作和C类似
函数内部修改了全局变量的话，会创建一个同名的局部变量，与外部的全局变量互不影响，所以内部修改不会影响到外面
不要试图在函数内部修改它，没有用，只能访问
用global修饰变量，则可以修改

内嵌函数

函数内部定义的函数
内部函数整个作用于都在外部函数之内

闭包

一种编程范式（面向过程、面向对象）
python几乎所有东西都是对象
对于在在一个内部函数里，对外部作用域的变量进行引用，则内部函数是一个闭包

>>> def FuncX(x):
    def FuncY(y):
        return x * y
    return FuncY

>>> i = FuncX(8)
>>> i
<function FuncX.<locals>.FuncY at 0x000000DED511EBF8>
>>> type(i)
<class 'function'>
>>> i(5)
40
>>> FuncX(10)(7) #直接输入两个参数
70
>>> 

>>> def Fun1():
    x = [5] #用元组存储数据不存储在栈上 不会被屏蔽
    def Fun2():
        x[0]*=x[0]
        return x[0]
    return Fun2()

>>> Fun1()
25
>>>

>>> def Fun1():
    x = 5
    def Fun2():
        nonlocal x #声明nonlocal 不会被屏蔽
        x*=x
        return x
    return Fun2()

>>> Fun1()
25
>>>

nonlocal 可以让之前的屏蔽取消 将外部变量的修改保存下来

匿名函数

lambda表达式
冒号前是参数列表 之后是函数体

>>> lambda x : 2 * x + 1
<function <lambda> at 0x000000DED511EF28>
>>> f = lambda x : 2 * x + 1
>>> f(5)
11
>>>

过滤器函数 filter

>>> def odd(x):#函数实现
    return x%2

>>> temp = range(10)
>>> show = filter(odd,temp)
>>> list(show)
[1, 3, 5, 7, 9]
>>> list(filter(lambda x : x % 2,range(10)))#一行实现
[1, 3, 5, 7, 9]
>>> 

映射 map

>>>